packages database,session cleaned and commented + minor revision communication

POO/src/communication/tcp/TCPClient.java

@@ -74,7 +74,7 @@ public class TCPClient {
 	}
 
 	/**
-	 * Method used when the session is over. Set all attribute references to null,
+	 * Method used when the session is over. Set all attributes' references to null,
 	 * interrupt the inputThread and close the streams and the socket.
 	 */
 	public void destroyAll() {

POO/src/communication/udp/CommunicationUDP.java

@@ -20,7 +20,7 @@ public class CommunicationUDP extends Thread {
 	private ObserverUserList obsList;
 
 	/**
-	 * Create the class that will manage the userlist and contain a UDPClient and a
+	 * Create the object that will manage the userlist and contain a UDPClient and a
 	 * UDPServer. Since the applications will run on localhost, it needs to know
 	 * every UDPServer ports used in order to replicate a broadcast behaviour.
 	 * 
@@ -63,7 +63,7 @@ public class CommunicationUDP extends Thread {
 		this.obsList = o;
 	}
 
-	// -------------- USER LIST UPDATE FUNCTION --------------//
+	// -------------- USER LIST UPDATE METHODS -------------- //
 
 	/**
 	 * Add a new user to the userlist and notify the observer.
@@ -128,7 +128,7 @@ public class CommunicationUDP extends Thread {
 	 * Check if there is an user in the list that has the given id.
 	 * 
 	 * @param id 	The user's id.
-	 * @return true if the user is in the list 
+	 * @return True if the user is in the list 
 	 * false otherwise.
 	 */
 	protected boolean containsUserFromID(String id) {
@@ -144,7 +144,7 @@ public class CommunicationUDP extends Thread {
 	 * Check if there is an user in the list that has the given pseudo.
 	 * 
 	 * @param pseudo 	The user's pseudo.
-	 * @return true if the user is in the list 
+	 * @return True if the user is in the list 
 	 * false otherwise.
 	 */
 	public boolean containsUserFromPseudo(String pseudo) {
@@ -191,7 +191,7 @@ public class CommunicationUDP extends Thread {
 		return -1;
 	}
 
-	// -------------- SEND MESSAGES --------------//
+	// -------------- SEND MESSAGES METHODS -------------- //
 
 	/**
 	 * Send a message indicating this application's user is connected to every
@@ -280,6 +280,9 @@ public class CommunicationUDP extends Thread {
 		}
 	}
 	
+	
+	// -------------- OTHERS -------------- //
+
 	/**
 	 * Notify the observer with the updated list
 	 */

POO/src/communication/udp/UDPClient.java

@@ -14,7 +14,7 @@ class UDPClient {
 	private DatagramSocket sockUDP;
 
 	/**
-	 * Create a UDP client on the specified port. It will be used to notify the
+	 * Create an UDP client on the specified port. It will be used to notify the
 	 * other users of this application's user state (Connected/Disconnected/Pseudo
 	 * changed).
 	 * 

POO/src/communication/udp/UDPServer.java

@@ -17,7 +17,7 @@ class UDPServer extends Thread {
 
 	
 	/**
-	 * Create a UDP Server on the specified port. It will be used to read the
+	 * Create an UDP Server on the specified port. It will be used to read the
 	 * other users states (Connected/Disconnected/Pseudo).
 	 * 
 	 * @param port

POO/src/database/SQLiteCreateTables.java

@@ -6,7 +6,19 @@ import java.sql.Statement;
 
 class SQLiteCreateTables {
 
-	
+	/**
+	 * Create the user table if it does not exist in the database.
+	 * An user is characterized by :
+	 * - an unique username, 
+	 * - a password salt,
+	 * - a database_key salt,
+	 * - a password hash encrypted by the database_key,
+	 * - the encrypted database_key,
+	 * - the initialization vector used to encrypt the database key.
+	 * 
+	 * @param connec 	The opened connection to the database.
+	 * @throws SQLException
+	 */
 	protected static void createTableUser(Connection connec) throws SQLException {
 		String createTableUser = "CREATE TABLE IF NOT EXISTS user (\r\n"
 				+ "    id                     INTEGER       PRIMARY KEY AUTOINCREMENT,\r\n"
@@ -16,29 +28,49 @@ class SQLiteCreateTables {
 				+ "    db_datakey_salt        BLOB,\r\n"
 				+ "    encrypted_pwd_hashsalt BLOB,\r\n" 
 				+ "    encrypted_db_datakey   BLOB,\r\n"
-				+ "    iv_datakey             BLOB\r\n"
+				+ "    iv_datakey             BLOB\r\n" + ");";
-				+ ");";
 
 		Statement stmt = connec.createStatement();
 		stmt.execute(createTableUser);
 
 	}
 
+	/**
+	 * Create the conversation table if it does not exist in the database.
+	 * A conversation is characterized by :
+	 * - the id of the user who sends the messages,
+	 * - the id of the user who receives the messages,
+	 * - an initialization vector used to encrypt the conversation's messages.
+	 * 
+	 * During an session between two users, two conversations are created.
+	 * 
+	 * @param connec 	The opened connection to the database.
+	 * @throws SQLException
+	 */
 	protected static void createTableConversation(Connection connec) throws SQLException {
 		String createTableConversation = "CREATE TABLE IF NOT EXISTS conversation (\r\n"
 				+ "    id_conversation INTEGER PRIMARY KEY AUTOINCREMENT,\r\n"
-				+ "    id_emetteur     INTEGER REFERENCES user (id) \r\n" 
+				+ "    id_sender     INTEGER REFERENCES user (id) \r\n" + "                            NOT NULL,\r\n"
-				+ "                            NOT NULL,\r\n"
+				+ "    id_receiver    INTEGER REFERENCES user (id) \r\n" + "                            NOT NULL,\r\n"
-				+ "    id_recepteur    INTEGER REFERENCES user (id) \r\n" 
+				+ "    iv_conversation BLOB NOT NULL" + ");";
-				+ "                            NOT NULL,\r\n"
-				+"     iv_conversation BLOB NOT NULL"
-				+ ");";
 
 		Statement stmt = connec.createStatement();
 		stmt.execute(createTableConversation);
 
 	}
 
+	/**
+	 * Create the message table if it does not exist in the database.
+	 * A message is characterized by :
+	 * - the id of the conversation it belongs,
+	 * - the id of its type,
+	 * - its content,
+	 * - the date when it was emitted,
+	 * - its extension if it is a file (text or image).
+	 * 
+	 * @param connec 	The opened connection to the database.
+	 * @throws SQLException
+	 */
 	protected static void createTableMessage(Connection connec) throws SQLException {
 		String createTableMessage = "CREATE TABLE IF NOT EXISTS message (\r\n"
 				+ "    id_message      INTEGER      PRIMARY KEY AUTOINCREMENT,\r\n"
@@ -48,15 +80,27 @@ class SQLiteCreateTables {
 				+ "                                 NOT NULL,\r\n" 
 				+ "    content         BLOB,\r\n"
 				+ "    date            INTEGER      NOT NULL,\r\n" 
-				+ "    extension       VARCHAR (20) \r\n"
+				+ "    extension       VARCHAR (20) \r\n" + ");\r\n";
-				+ ");\r\n";
 
 		Statement stmt = connec.createStatement();
 		stmt.execute(createTableMessage);
 	}
 
+	/**
+	 * Create the (message) type table if it does not exist and insert the different
+	 * types of message in the database.
+	 * A type is characterized by :
+	 * - a label.
+	 * 
+	 * This table only exists because the type "enumeration" does not exist in SQLite.
+	 * It is a static table that contains the different types of message stored in the database.
+	 * 
+	 * @param connec 	The opened connection to the database.
+	 * @throws SQLException
+	 */
 	protected static void createTableType(Connection connec) throws SQLException {
-		String createTableType = "CREATE TABLE IF NOT EXISTS type (\r\n" + "    id_type INTEGER      PRIMARY KEY,\r\n"
+		String createTableType = "CREATE TABLE IF NOT EXISTS type (\r\n" 
+				+ "    id_type INTEGER      PRIMARY KEY,\r\n"
 				+ "    label VARCHAR (20) NOT NULL\r\n" + ");";
 
 		Statement stmt = connec.createStatement();

POO/src/database/SQLiteEncprytion.java

@@ -1,84 +0,0 @@
-package database;
-
-
-import java.util.Base64;
-import java.util.Random;
-
-import javax.crypto.*;
-import javax.crypto.spec.*;
-import java.security.*;
-import java.security.spec.*;
-
-class SQLiteEncprytion {
-	
-	private static final Random RANDOM = new SecureRandom();
-	private static final int ITERATIONS = 10000;
-	private static final int KEY_LENGTH = 256;
-	protected static final String encryptAlgorithm = "AES/CBC/PKCS5Padding";
-	
-	protected static byte[] getNextSalt() {
-		byte[] salt = new byte[24];
-		RANDOM.nextBytes(salt); 
-		return salt;
-	}
-	
-	
-	protected static byte[] hash(char[] password, byte[] salt) {
-		return SQLiteEncprytion.getKey(password, salt).getEncoded();
-	}
-	
-	
-	protected static SecretKey getKey(char[] password, byte[] salt) {
-		PBEKeySpec saltpwd = new PBEKeySpec(password, salt, ITERATIONS, KEY_LENGTH);
-		
-		try {
-			SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
-			SecretKey tmp = skf.generateSecret(saltpwd);
-			SecretKey key = new SecretKeySpec(tmp.getEncoded(), "AES");
-			return key;
-		} catch (InvalidKeySpecException | NoSuchAlgorithmException e) {
-			e.printStackTrace();
-		} finally {
-			saltpwd.clearPassword();
-		}
-		return null;
-	}
-	
-	
-	public static IvParameterSpec generateIv() {
-	    byte[] iv = new byte[16];
-	    new SecureRandom().nextBytes(iv);
-	    return new IvParameterSpec(iv);
-	}
-	
-	
-	protected static byte[] encrypt(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException{
-		Cipher cipher = Cipher.getInstance(algorithm);
-		cipher.init(Cipher.ENCRYPT_MODE, key, iv);
-		byte[] cipherText = cipher.doFinal(input);
-		return Base64.getEncoder().encode(cipherText);
-	}
-	
-	
-	protected static byte[] decryptByte(String algorithm, byte[] cipherText, SecretKey key, IvParameterSpec iv) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException{
-		Cipher cipher = Cipher.getInstance(algorithm);
-		cipher.init(Cipher.DECRYPT_MODE, key, iv);
-		byte[] plainText = cipher.doFinal(Base64.getDecoder().decode(cipherText));
-		return plainText;
-	}
-	
-	protected static String decryptString(String algorithm, byte[] cipherText, SecretKey key, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
-		return new String(SQLiteEncprytion.decryptByte(algorithm, cipherText, key, iv) );
-	}
-	
-	
-	public static byte[] keyToByte(SecretKey key) {
-		return Base64.getEncoder().encode(key.getEncoded());
-	}
-	
-	
-	public static SecretKey byteToKey(byte[] encodedKey) {
-		byte[] decodedKey = Base64.getDecoder().decode(encodedKey);
-		return new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES");
-	}
-}

POO/src/database/SQLiteEncryption.java

@@ -0,0 +1,158 @@
+package database;
+
+import java.util.Base64;
+import java.util.Random;
+
+import javax.crypto.*;
+import javax.crypto.spec.*;
+import java.security.*;
+import java.security.spec.*;
+
+class SQLiteEncryption {
+
+	private static final Random RANDOM = new SecureRandom();
+	private static final int ITERATIONS = 10000;
+	private static final int KEY_LENGTH = 256;
+	protected static final String encryptAlgorithm = "AES/CBC/PKCS5Padding";
+
+	/**
+	 * Return a 24 bytes salt.
+	 * 
+	 * @return The salt in a byte array.
+	 */
+	protected static byte[] getNextSalt() {
+		byte[] salt = new byte[24];
+		RANDOM.nextBytes(salt);
+		return salt;
+	}
+
+	/**
+	 * Return the hash of the given password with the given salt.
+	 * 
+	 * @param password
+	 * @param salt
+	 * @return The hash in a byte array.
+	 */
+	protected static byte[] hash(char[] password, byte[] salt) {
+		return SQLiteEncryption.getKey(password, salt).getEncoded();
+	}
+
+	/**
+	 * Return a secret key generated with the given password and salt.
+	 * 
+	 * @param password
+	 * @param salt
+	 * @return The secret key.
+	 */
+	protected static SecretKey getKey(char[] password, byte[] salt) {
+		PBEKeySpec saltpwd = new PBEKeySpec(password, salt, ITERATIONS, KEY_LENGTH);
+
+		try {
+			SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
+			SecretKey tmp = skf.generateSecret(saltpwd);
+			SecretKey key = new SecretKeySpec(tmp.getEncoded(), "AES");
+			return key;
+		} catch (InvalidKeySpecException | NoSuchAlgorithmException e) {
+			e.printStackTrace();
+		} finally {
+			saltpwd.clearPassword();
+		}
+		return null;
+	}
+
+	/**
+	 * Return a 16 bytes Initialization vector.
+	 * 
+	 * @return The Initialization vector.
+	 */
+	protected static IvParameterSpec generateIv() {
+		byte[] iv = new byte[16];
+		RANDOM.nextBytes(iv);
+		return new IvParameterSpec(iv);
+	}
+
+	/**
+	 * Encrypt the given input (byte array) with the given algorithm, secretKey and
+	 * initialization vector.
+	 * 
+	 * 
+	 * @param algorithm
+	 * @param input
+	 * @param key
+	 * @param iv
+	 * @return The encrypted input in a byte array.
+	 * 
+	 * @throws NoSuchAlgorithmException
+	 * @throws NoSuchPaddingException
+	 * @throws InvalidKeyException
+	 * @throws InvalidAlgorithmParameterException
+	 * @throws IllegalBlockSizeException
+	 * @throws BadPaddingException
+	 */
+	protected static byte[] encrypt(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv)
+			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
+			InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
+		Cipher cipher = Cipher.getInstance(algorithm);
+		cipher.init(Cipher.ENCRYPT_MODE, key, iv);
+		byte[] cipherText = cipher.doFinal(input);
+		return Base64.getEncoder().encode(cipherText);
+	}
+
+	/**
+	 * Decrypt the given input (byte array) with the given algorithm, secretKey and
+	 * initialization vector.
+	 * 
+	 * @param algorithm
+	 * @param input
+	 * @param key
+	 * @param iv
+	 * @return The decrypted input in a byte array.
+	 * 
+	 * @throws NoSuchAlgorithmException
+	 * @throws NoSuchPaddingException
+	 * @throws InvalidKeyException
+	 * @throws InvalidAlgorithmParameterException
+	 * @throws IllegalBlockSizeException
+	 * @throws BadPaddingException
+	 */
+	protected static byte[] decryptByte(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv)
+			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
+			InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
+		Cipher cipher = Cipher.getInstance(algorithm);
+		cipher.init(Cipher.DECRYPT_MODE, key, iv);
+		byte[] plainText = cipher.doFinal(Base64.getDecoder().decode(input));
+		return plainText;
+	}
+
+	/**
+	 * Decrypt the given input (byte array) with the given algorithm, secretKey and
+	 * initialization vector.
+	 * 
+	 * @param algorithm
+	 * @param input
+	 * @param key
+	 * @param iv
+	 * @return The decrypted input as a String.
+	 * 
+	 * @throws InvalidKeyException
+	 * @throws NoSuchAlgorithmException
+	 * @throws NoSuchPaddingException
+	 * @throws InvalidAlgorithmParameterException
+	 * @throws IllegalBlockSizeException
+	 * @throws BadPaddingException
+	 */
+	protected static String decryptString(String algorithm, byte[] input, SecretKey key, IvParameterSpec iv)
+			throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
+			InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
+		return new String(SQLiteEncryption.decryptByte(algorithm, input, key, iv));
+	}
+
+	protected static byte[] keyToByte(SecretKey key) {
+		return Base64.getEncoder().encode(key.getEncoded());
+	}
+
+	protected static SecretKey byteToKey(byte[] encodedKey) {
+		byte[] decodedKey = Base64.getDecoder().decode(encodedKey);
+		return new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES");
+	}
+}

POO/src/database/SQLiteManager.java

@@ -1,6 +1,5 @@
 package database;
 
-import java.io.File;
 import java.security.InvalidAlgorithmParameterException;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
@@ -19,7 +18,6 @@ import javax.crypto.NoSuchPaddingException;
 import javax.crypto.SecretKey;
 import javax.crypto.spec.IvParameterSpec;
 
-
 import main.Utilisateur;
 import messages.MauvaisTypeMessageException;
 import messages.Message;
@@ -31,13 +29,24 @@ public class SQLiteManager {
 
 	private static final String DATABASE_RELATIVE_PATH = "../database";
 
-	public static String[] hardcodedNames = {"Olivia","Liam","Benjamin","Sophia","Charlotte","Noah","Elijah","Isabella",
+	public static String[] hardcodedNames = { "Olivia", "Liam", "Benjamin", "Sophia", "Charlotte", "Noah", "Elijah",
-			"Oliver","Emma","William","Amelia","Evelyn","James","Mia","Ava","Lucas","Mason","Ethan","Harper"};
+			"Isabella", "Oliver", "Emma", "William", "Amelia", "Evelyn", "James", "Mia", "Ava", "Lucas", "Mason",
+			"Ethan", "Harper" };
 
 	private Connection connec;
 	private int numDatabase;
 	private SecretKey dbDataKey;
 
+	
+	/**
+	 * Create the object that will interact with the database. Each time a
+	 * SQLiteManager is created, it creates the tables for the application to work
+	 * if they do not exist already. In the context of a local usage of the
+	 * application, this constructor takes a number that is used to manage different
+	 * database's files (see openConnection() ).
+	 * 
+	 * @param numDatabase
+	 */
 	public SQLiteManager(int numDatabase) {
 		this.numDatabase = numDatabase;
 
@@ -52,28 +61,31 @@ public class SQLiteManager {
 
 		} catch (SQLException e) {
 			this.closeConnection();
-			File db = new File("../database"+this.numDatabase+".db");
-			if(db.delete()) {
-				System.out.println("supp");
-			}else {
-				System.out.println("no supp");
-			}
 			e.printStackTrace();
 		}
 
 		this.closeConnection();
 	}
 
+	
+	// -------------- CONNECTION METHODS -------------- //
+	
+	/**
+	 * Open a connection to the file DATABASE_RELATIVE_PATH+this.numDatabase+".db"
+	 */
 	private void openConnection() {
 		String url = "jdbc:sqlite:" + DATABASE_RELATIVE_PATH + this.numDatabase + ".db";
 		try {
 			this.connec = DriverManager.getConnection(url);
-//			System.out.println("Connection to bdd established");
 		} catch (SQLException e) {
 			System.out.println(e.getMessage());
 		}
 	}
 
+	
+	/**
+	 * Close this object connection, if it exists
+	 */
 	private void closeConnection() {
 		try {
 			if (this.connec != null) {
@@ -85,7 +97,22 @@ public class SQLiteManager {
 
 	}
 
-	public int insertAllMessages(ArrayList<Message> messages, String usernameSender, String usernameReceiver) throws SQLException{
+	
+	// -------------- INSERT METHODS -------------- //
+
+	/**
+	 * Insert a collection of message in the database. They all correspond to the
+	 * conversation between the sender and the receiver. The users and conversations
+	 * are inserted in the database if they do not exist when this method is called.
+	 * 
+	 * @param messages
+	 * @param usernameSender
+	 * @param usernameReceiver
+	 * @return The number of messages inserted
+	 * @throws SQLException
+	 */
+	public int insertAllMessages(ArrayList<Message> messages, String usernameSender, String usernameReceiver)
+			throws SQLException {
 		int nbRows = 0;
 		this.openConnection();
 
@@ -111,6 +138,7 @@ public class SQLiteManager {
 
 		IvParameterSpec ivConversation = this.getIvConversation(idConversation);
 
+		// Disable autocommit to efficiently insert all the messages.
 		this.connec.setAutoCommit(false);
 
 		for (Message m : messages) {
@@ -122,46 +150,143 @@ public class SQLiteManager {
 			}
 		}
 
+		// Commit once all the messages are inserted
 		this.connec.commit();
 
 		this.closeConnection();
 
-		//System.out.println("Nombre de message(s) insérée(s) : " + nbRows);
-		
 		return nbRows;
 	}
 
 	
-	public ArrayList<Message> getHistoriquesMessages(String usernameOther, String pseudoOther) throws SQLException {
+	/**
+	 * Insert a message corresponding to a given conversation (respresented by its
+	 * id). The message content is first encrypted with the database key and the
+	 * given iv.
+	 * 
+	 * @param idConversation
+	 * @param m
+	 * @param iv
+	 * @return The number of rows inserted (it should be 1).
+	 * @throws SQLException
+	 */
+	private int insertMessage(int idConversation, Message m, IvParameterSpec iv) throws SQLException {
+
+		String dateMessage = m.getDateMessage();
+		String extension = this.processExtension(m);
+		String type = this.processMessageType(m);
+		int idType = this.getIDType(type);
+
+		byte[] content = null;
+
+		try {
+			content = this.stringToBytesContent(m, iv);
+		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
+				| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
+
+			e.printStackTrace();
+		}
+
+		String insertMessageRequest = "INSERT INTO message(id_conversation, id_type, content, date, extension) "
+				+ "VALUES (?, ?, ?, ?, ?);";
+
+		PreparedStatement prepStmt = this.connec.prepareStatement(insertMessageRequest);
+		prepStmt.setInt(1, idConversation);
+		prepStmt.setInt(2, idType);
+		prepStmt.setBytes(3, content);
+		prepStmt.setString(4, dateMessage);
+		prepStmt.setString(5, extension);
+
+		int nbRows = prepStmt.executeUpdate();
+
+		return nbRows;
+	}
+
+	
+	/**
+	 * Insert an user in the database with only its username.
+	 * 
+	 * @param username
+	 * @throws SQLException
+	 */
+	private void insertUser(String username) throws SQLException {
+		String insertUserRequest = "INSERT INTO user (username) " + "VALUES (?);";
+
+		PreparedStatement prepStmt = this.connec.prepareStatement(insertUserRequest);
+		prepStmt.setString(1, username);
+		prepStmt.executeUpdate();
+	}
+
+	
+	/**
+	 * Insert the two conversations corresponding to a session between two users
+	 * (they both can be sender and receiver).
+	 * 
+	 * @param idUser1
+	 * @param idUser2
+	 * @throws SQLException
+	 */
+	private void insertConversation(int idUser1, int idUser2) throws SQLException {
+		String insertConversationRequest = "INSERT INTO conversation (id_sender, id_receiver, iv_conversation) "
+				+ "VALUES " + "(?, ?, ?)," + "(?, ?, ?);";
+
+		byte[] ivConversation = SQLiteEncryption.generateIv().getIV();
+
+		PreparedStatement prepStmt = this.connec.prepareStatement(insertConversationRequest);
+		prepStmt.setInt(1, idUser1);
+		prepStmt.setInt(2, idUser2);
+		prepStmt.setBytes(3, ivConversation);
+		prepStmt.setInt(4, idUser2);
+		prepStmt.setInt(5, idUser1);
+		prepStmt.setBytes(6, ivConversation);
+
+		prepStmt.executeUpdate();
+	}
+
+	
+	// -------------- GET METHODS -------------- //
+
+	/**
+	 * Get the message record between two users. In context, it only needs the
+	 * username and the id of the other user since we can get this application's
+	 * user's data with Utilisateur.getSelf().
+	 * 
+	 * @param usernameOther
+	 * @param pseudoOther
+	 * @return the messages previously exchanged in chronological order or null if
+	 *         there is none.
+	 * @throws SQLException
+	 */
+	public ArrayList<Message> getMessageRecord(String usernameOther, String pseudoOther) throws SQLException {
 
 		this.openConnection();
 
-		
 		ArrayList<Message> messages = new ArrayList<Message>();
 
 		String usernameSelf = Utilisateur.getSelf().getId();
 
+		// Get the ids from the usernames
 		int idSelf = this.getIDUser(usernameSelf);
 		int idOther = this.getIDUser(usernameOther);
 
+		// Get the two conversations corresponding to the exchanges between the two
+		// users
 		int idConversationSelf = this.getIDConversation(idSelf, idOther);
 		int idConversationOther = this.getIDConversation(idOther, idSelf);
 		IvParameterSpec ivConversation = this.getIvConversation(idConversationSelf);
-//		String str = "datetime(d1,'unixepoch','localtime')";
 
-		
+		// Get all the messages
-		String getHistoriqueRequest = "SELECT id_conversation, id_type, content, date, extension "
+		String getHistoriqueRequest = "SELECT id_conversation, id_type, content, date, extension " + "FROM message "
-									+ "FROM message "
+				+ "WHERE id_conversation IN (?,?) " + "ORDER by date";
-									+ "WHERE id_conversation IN (?,?) "
-									+ "ORDER by date";
 
 		PreparedStatement prepStmt = this.connec.prepareStatement(getHistoriqueRequest);
 		prepStmt.setInt(1, idConversationSelf);
 		prepStmt.setInt(2, idConversationOther);
 		ResultSet res = prepStmt.executeQuery();
 
-		//Retrieve the messages one by one
+		// Process the messages one by one
-		//Create the appropriate message object depending on the type and sender/receiver
+		// Create the appropriate message object depending on the type and
+		// sender/receiver
 		// and add the message in the list
 		while (res.next()) {
 			int idType = res.getInt("id_type");
@@ -169,11 +294,12 @@ public class SQLiteManager {
 
 			String content = null;
 			try {
+				// Decrypt the message's content with the database key and the conversation's
+				// iv.
 				content = this.bytesToStringContent(res.getBytes("content"), ivConversation);
 			} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 					| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException
 					| SQLException e1) {
-				//System.out.println("erreur déchiffrement");
 			}
 
 			Message message = null;
@@ -211,22 +337,20 @@ public class SQLiteManager {
 
 		}
 
-		
 		this.closeConnection();
 
 		return messages;
 	}
 
 	
-	private void insertUser(String username) throws SQLException {
+	/**
-		String insertUserRequest = "INSERT INTO user (username) " + "VALUES (?);";
+	 * Return the id of the user with the given username if it exists in the
-
+	 * database.
-		PreparedStatement prepStmt = this.connec.prepareStatement(insertUserRequest);
+	 * 
-		prepStmt.setString(1, username);
+	 * @param username
-		prepStmt.executeUpdate();
+	 * @return The id of the user or -1 if he does not exist in the database.
-	}
+	 * @throws SQLException
-	
+	 */
-	
 	private int getIDUser(String username) throws SQLException {
 		String getIDRequest = "SELECT id " + " FROM user" + " WHERE username = ? ;";
 
@@ -242,28 +366,18 @@ public class SQLiteManager {
 	}
 
 	
-	private void insertConversation(int idSender, int idReceiver) throws SQLException {
+	/**
-		String insertConversationRequest = "INSERT INTO conversation (id_emetteur, id_recepteur, iv_conversation) " + "VALUES "
+	 * Get the id of the conversation between two users (represented by their ids).
-				+ "(?, ?, ?),"
+	 * 
-				+ "(?, ?, ?);";
+	 * @param idSender
-
+	 * @param idReceiver
-		byte[] ivConversation = SQLiteEncprytion.generateIv().getIV();
+	 * @return The id of the conversation or -1 if the conversation does not exists
-		
+	 *         in the database.
-		PreparedStatement prepStmt = this.connec.prepareStatement(insertConversationRequest);
+	 * @throws SQLException
-		prepStmt.setInt(1, idSender);
+	 */
-		prepStmt.setInt(2, idReceiver);
-		prepStmt.setBytes(3, ivConversation);
-		prepStmt.setInt(4, idReceiver);
-		prepStmt.setInt(5, idSender);
-		prepStmt.setBytes(6, ivConversation);
-		
-		prepStmt.executeUpdate();
-	}
-	
-	
 	private int getIDConversation(int idSender, int idReceiver) throws SQLException {
-		String getIDRequest = "SELECT id_conversation " + "FROM conversation " + "WHERE id_emetteur = ? "
+		String getIDRequest = "SELECT id_conversation " + "FROM conversation " + "WHERE id_sender = ? "
-				+ "AND id_recepteur = ? ;";
+				+ "AND id_receiver = ? ;";
 
 		PreparedStatement prepStmt = this.connec.prepareStatement(getIDRequest);
 		prepStmt.setInt(1, idSender);
@@ -276,6 +390,16 @@ public class SQLiteManager {
 		return -1;
 	}
 
+	
+	/**
+	 * Get the initialization vector for a given conversation (represented by its
+	 * id).
+	 * 
+	 * @param idConversation
+	 * @return The iv corresponding to the conversation or null if the conversation
+	 *         does not exist in the database.
+	 * @throws SQLException
+	 */
 	private IvParameterSpec getIvConversation(int idConversation) throws SQLException {
 		String getIvRequest = "SELECT iv_conversation " + "FROM conversation " + "WHERE id_conversation = ?;";
 
@@ -291,8 +415,14 @@ public class SQLiteManager {
 	}
 
 	
-
+	/**
-	
+	 * Get the id of the message type corresponding to the given label.
+	 * 
+	 * @param label
+	 * @return The id of the message type or -1 if it does not exist in the
+	 *         database.
+	 * @throws SQLException
+	 */
 	private int getIDType(String label) throws SQLException {
 		String getIDRequest = "SELECT id_type FROM type WHERE label = ?;";
 
@@ -308,6 +438,14 @@ public class SQLiteManager {
 	}
 
 	
+	/**
+	 * Get the label of the message type corresponding to the given id.
+	 * 
+	 * @param idType
+	 * @return The label of the message type or "" if it does not exist in the
+	 *         database.
+	 * @throws SQLException
+	 */
 	private String getType(int idType) throws SQLException {
 		String getTypeRequest = "SELECT label FROM type WHERE id_type = ?;";
 
@@ -325,7 +463,26 @@ public class SQLiteManager {
 	}
 
 	
-	private byte[] stringToBytesContent(Message m, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
+	// -------------- PROCESSING MESSAGE METHODS -------------- //
+	
+	/**
+	 * Convert a message in bytes. First get the content of the message. Then
+	 * encrypt it with the database_key and the given iv (initialization vector).
+	 * 
+	 * @param m
+	 * @param iv
+	 * @return The bytes of the encrypted message's content.
+	 * 
+	 * @throws InvalidKeyException
+	 * @throws NoSuchAlgorithmException
+	 * @throws NoSuchPaddingException
+	 * @throws InvalidAlgorithmParameterException
+	 * @throws IllegalBlockSizeException
+	 * @throws BadPaddingException
+	 */
+	private byte[] stringToBytesContent(Message m, IvParameterSpec iv)
+			throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
+			InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
 		String content;
 		if (m.getTypeMessage() == TypeMessage.TEXTE) {
 			MessageTexte messageTxt = (MessageTexte) m;
@@ -334,25 +491,61 @@ public class SQLiteManager {
 			MessageFichier messageFichier = (MessageFichier) m;
 			content = messageFichier.getContenu();
 		}
-		byte[] encryptedContent = SQLiteEncprytion.encrypt(SQLiteEncprytion.encryptAlgorithm, content.getBytes(), this.dbDataKey, iv);
+		byte[] encryptedContent = SQLiteEncryption.encrypt(SQLiteEncryption.encryptAlgorithm, content.getBytes(),
+				this.dbDataKey, iv);
 		return encryptedContent;
 
 	}
 
-	private String bytesToStringContent(byte[] encryptedContent, IvParameterSpec iv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
+	
-		return SQLiteEncprytion.decryptString(SQLiteEncprytion.encryptAlgorithm, encryptedContent, this.dbDataKey, iv);
+	/**
+	 * Convert bytes in a String. In this context, the bytes correspond to the
+	 * encrypted content of a message.
+	 * 
+	 * @param encryptedContent
+	 * @param iv
+	 * @return The String corresponding to the decrypted bytes.
+	 * 
+	 * @throws InvalidKeyException
+	 * @throws NoSuchAlgorithmException
+	 * @throws NoSuchPaddingException
+	 * @throws InvalidAlgorithmParameterException
+	 * @throws IllegalBlockSizeException
+	 * @throws BadPaddingException
+	 */
+	private String bytesToStringContent(byte[] encryptedContent, IvParameterSpec iv)
+			throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
+			InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
+		return SQLiteEncryption.decryptString(SQLiteEncryption.encryptAlgorithm, encryptedContent, this.dbDataKey, iv);
 	}
 
 	
+	/**
+	 * Process the type of a message
+	 * 
+	 * @param m
+	 * @return The type of the message
+	 */
 	private String processMessageType(Message m) {
 		switch (m.getTypeMessage()) {
-		case TEXTE: return "text";
+		case TEXTE:
-		case FICHIER: return "file";			
+			return "text";
-		case IMAGE: return "image";
+		case FICHIER:
-		default: return "";
+			return "file";
+		case IMAGE:
+			return "image";
+		default:
+			return "";
 		}
 	}
 
+	
+	/**
+	 * Process the extension of a message
+	 * 
+	 * @param m
+	 * @return The extension of the message. null if it is a simple text message.
+	 */
 	private String processExtension(Message m) {
 		if (m.getTypeMessage() == TypeMessage.TEXTE) {
 			return null;
@@ -362,44 +555,24 @@ public class SQLiteManager {
 		}
 	}
 
-	
+	// -------------- USER SECURITY RELATED METHODS -------------- //
-	private int insertMessage(int idConversation, Message m, IvParameterSpec iv) throws SQLException {
 
 	
-			String dateMessage = m.getDateMessage();
+	/**
-			String extension = this.processExtension(m);
+	 * Creates a new user in the database from a given username and password. The
-			String type = this.processMessageType(m);
+	 * username is stored in plain text. An encrypted hash of the password is
-			int idType = this.getIDType(type);
+	 * stored. The key used to encrypt the password's hash is itself encrypted then
-			
+	 * stored. Every other useful data to decrypt the key and compare the password's
-			byte[] content = null;
+	 * hash is stored as plaintext.
-			
+	 * 
-			try {
+	 * Fail if a user with the given username already exists in the database.
-				content = this.stringToBytesContent(m, iv);
+	 * 
-			} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
+	 * @param username
-					| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
+	 * @param password
-				
+	 */
-				e.printStackTrace();
-			}
-			
-			String insertMessageRequest = "INSERT INTO message(id_conversation, id_type, content, date, extension) "
-					+ "VALUES (?, ?, ?, ?, ?);";
-			
-			PreparedStatement prepStmt = this.connec.prepareStatement(insertMessageRequest);
-			prepStmt.setInt(1, idConversation);
-			prepStmt.setInt(2, idType);
-			prepStmt.setBytes(3, content);
-			prepStmt.setString(4, dateMessage);
-			prepStmt.setString(5, extension);
-			
-			int nbRows = prepStmt.executeUpdate();
-		
-		return nbRows;
-	}
-	
 	public void createNewUserEncrypt(String username, String password) {
 
-		
+		String algo = SQLiteEncryption.encryptAlgorithm;
-		String algo = SQLiteEncprytion.encryptAlgorithm;
 
 		KeyGenerator keyGen = null;
 		try {
@@ -409,28 +582,26 @@ public class SQLiteManager {
 			e.printStackTrace();
 		}
 
-		byte[] passwordSalt = SQLiteEncprytion.getNextSalt();
+		byte[] passwordSalt = SQLiteEncryption.getNextSalt();
-		byte[] dbDataKeySalt = SQLiteEncprytion.getNextSalt();
+		byte[] dbDataKeySalt = SQLiteEncryption.getNextSalt();
 
 		SecretKey dbDataKey = keyGen.generateKey();
 
-		SecretKey dbDataEncryptKey = SQLiteEncprytion.getKey(password.toCharArray(), dbDataKeySalt);
+		SecretKey dbDataEncryptKey = SQLiteEncryption.getKey(password.toCharArray(), dbDataKeySalt);
-		IvParameterSpec ivDbDataKey = SQLiteEncprytion.generateIv();
+		IvParameterSpec ivDbDataKey = SQLiteEncryption.generateIv();
 
-		byte[] passwordHash = SQLiteEncprytion.hash(password.toCharArray(), passwordSalt);
+		byte[] passwordHash = SQLiteEncryption.hash(password.toCharArray(), passwordSalt);
 
 		byte[] dbDataKeyEncrypted = null;
 		byte[] encryptedPasswordHash = null;
 
 		try {
-			dbDataKeyEncrypted = SQLiteEncprytion.encrypt(
+			dbDataKeyEncrypted = SQLiteEncryption.encrypt(algo, SQLiteEncryption.keyToByte(dbDataKey), dbDataEncryptKey,
-					algo, SQLiteEncprytion.keyToByte(dbDataKey), dbDataEncryptKey, ivDbDataKey);
+					ivDbDataKey);
-			encryptedPasswordHash = SQLiteEncprytion.encrypt(
+			encryptedPasswordHash = SQLiteEncryption.encrypt(algo, passwordHash, dbDataKey, ivDbDataKey);
-					algo, passwordHash , dbDataKey, ivDbDataKey);
 
 		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 				| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
-			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 
@@ -450,7 +621,6 @@ public class SQLiteManager {
 			prepStmt.setBytes(6, ivDbDataKey.getIV());
 
 		} catch (SQLException e) {
-			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 
@@ -465,13 +635,15 @@ public class SQLiteManager {
 
 	}
 
+	
 	/**
+	 * Check if a given password has the same hash (= they're the same) as the one
+	 * stored in the database for a given username.
 	 * 
 	 * @param username
 	 * @param password
-	 * @return -1 if user do not exists,
+	 * @return -1 if user do not exists, 0 if password is incorrect, 1 if password
-	 * 			0 if password incorrect,
+	 *         is correct
-	 * 			1 if password correct
 	 * @throws SQLException
 	 */
 	public int checkPwd(String username, char[] password) throws SQLException {
@@ -479,8 +651,7 @@ public class SQLiteManager {
 		this.openConnection();
 
 		String selectUserDataRequest = "SELECT pwd_salt, db_datakey_salt, encrypted_pwd_hashsalt, encrypted_db_datakey, iv_datakey "
-									+ "FROM user "
+				+ "FROM user " + "WHERE username = ?;";
-									+ "WHERE username = ?;";
 		PreparedStatement prepStmt;
 		prepStmt = this.connec.prepareStatement(selectUserDataRequest);
 		prepStmt.setString(1, username);
@@ -491,67 +662,94 @@ public class SQLiteManager {
 		}
 
 		byte[] passwordSalt = res.getBytes("pwd_salt");
+
+		if (passwordSalt == null) {
+			return 0;
+		}
+
 		byte[] dbDataKeySalt = res.getBytes("db_datakey_salt");
 
-		SecretKey dbDataEncryptKey = SQLiteEncprytion.getKey(password, dbDataKeySalt);
+		SecretKey dbDataEncryptKey = SQLiteEncryption.getKey(password, dbDataKeySalt);
-		IvParameterSpec iv = new IvParameterSpec(res.getBytes("iv_datakey"));
 
+		byte[] ivBytes = res.getBytes("iv_datakey");
+
+		if (ivBytes == null) {
+			return 0;
+		}
+
+		IvParameterSpec iv = new IvParameterSpec(ivBytes);
 		byte[] encryptedDbDataKey = res.getBytes("encrypted_db_datakey");
 
-		
 		SecretKey dbDataKey = null;
 		try {
-			 dbDataKey = SQLiteEncprytion.byteToKey(
+			dbDataKey = SQLiteEncryption.byteToKey(SQLiteEncryption.decryptByte(SQLiteEncryption.encryptAlgorithm,
-					SQLiteEncprytion.decryptByte(SQLiteEncprytion.encryptAlgorithm, encryptedDbDataKey, dbDataEncryptKey, iv)
+					encryptedDbDataKey, dbDataEncryptKey, iv));
-					);
 		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 				| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
-			//System.out.println("Problème déchiffrement clé db");
 		}
 
-		this.dbDataKey = dbDataKey;
-		
 		byte[] encryptedPasswordHash = res.getBytes("encrypted_pwd_hashsalt");
 
-		
+		byte[] passwordHash = SQLiteEncryption.hash(password, passwordSalt);
-		byte[] passwordHash = SQLiteEncprytion.hash(password, passwordSalt);
 
 		this.closeConnection();
 
 		boolean checkHash = this.checkHashPwd(passwordHash, encryptedPasswordHash, dbDataKey, iv);
 		if (checkHash) {
+
+			// Set the database key to be used in future encryptions if the given password is
+			// correct.
+			this.dbDataKey = dbDataKey;
 			return 1;
 		}
+
 		return 0;
 	}
 	
 
-	private boolean checkHashPwd(byte[] passwordHash, byte[] encryptedPasswordHash, SecretKey dbDataKey, IvParameterSpec iv) {
+	/**
+	 * Check if two given hash are the same once the second one has been decrypted
+	 * with the given key and iv.
+	 * 
+	 * @param passwordHash
+	 * @param encryptedPasswordHash
+	 * @param dbDataKey
+	 * @param iv
+	 * @return true if the first hash is equal to the second one once decrypted,
+	 *         false otherwise.
+	 * 
+	 */
+	private boolean checkHashPwd(byte[] passwordHash, byte[] encryptedPasswordHash, SecretKey dbDataKey,
+			IvParameterSpec iv) {
 
 		byte[] expectedHash = "".getBytes();
 		try {
-			expectedHash = SQLiteEncprytion.decryptByte(SQLiteEncprytion.encryptAlgorithm, encryptedPasswordHash, dbDataKey, iv);
+			expectedHash = SQLiteEncryption.decryptByte(SQLiteEncryption.encryptAlgorithm, encryptedPasswordHash,
+					dbDataKey, iv);
 		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
 				| InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
 		}
 
-		
+		if (passwordHash.length != expectedHash.length)
-		
+			return false;
-		if (passwordHash.length != expectedHash.length) return false;
 		for (int i = 0; i < passwordHash.length; i++) {
-	      if (passwordHash[i] != expectedHash[i]) return false;
+			if (passwordHash[i] != expectedHash[i])
+				return false;
 		}
 		return true;
 	}
 	
 	
+
+	// Main to create 20 users in the database with the given number
 	public static void main(String[] args) {
 		String[] hardcodedNames = { "Olivia", "Liam", "Benjamin", "Sophia", "Charlotte", "Noah", "Elijah", "Isabella",
-				"Oliver","Emma","William","Amelia","Evelyn","James","Mia","Ava","Lucas","Mason","Ethan","Harper"};
+				"Oliver", "Emma", "William", "Amelia", "Evelyn", "James", "Mia", "Ava", "Lucas", "Mason", "Ethan",
+				"Harper" };
 
 		String pwdPrefix = "aze1$";
 
-		SQLiteManager sqlManager = new SQLiteManager(1);
+		SQLiteManager sqlManager = new SQLiteManager(0);
 
 		for (int i = 0; i < hardcodedNames.length; i++) {
 			sqlManager.createNewUserEncrypt(hardcodedNames[i] + i, pwdPrefix + hardcodedNames[i].charAt(0) + i);

POO/src/session/ControleurSession.java

@@ -39,17 +39,22 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 	private SQLiteManager sqlManager;
 	private ArrayList<File> files;
 
-	
 	/**
+	 * Create the controller for this session. It will manage all the objects used
+	 * to send/receive messages and files as well as the ones interacting with the
+	 * database. It will handle the actions performed on the view and call the
+	 * appropriate methods to display messages and data on the view.
 	 * 
-	 * @param vue
+	 * @param vue         		The corresponding view
-	 * @param socketComm
+	 * @param socketComm  		The socket used to send/receive messages
-	 * @param idOther
+	 * @param idOther     		The other user's id
-	 * @param pseudoOther
+	 * @param pseudoOther 		The other user's pseudo
-	 * @param sqlManager
+	 * @param sqlManager  		The SQLManager instance to retrieve/insert
+	 *                   		users,conversations,messages from/into the database
 	 * @throws IOException
 	 */
-	protected ControleurSession(VueSession vue, Socket socketComm, String idOther, String pseudoOther, SQLiteManager sqlManager) throws IOException {
+	protected ControleurSession(VueSession vue, Socket socketComm, String idOther, String pseudoOther,
+			SQLiteManager sqlManager) throws IOException {
 		this.vue = vue;
 		this.tcpClient = new TCPClient(socketComm);
 		this.tcpClient.setObserverInputThread(this);
@@ -66,6 +71,7 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 		this.files = new ArrayList<File>();
 	}
 
+	
 	// ---------- ACTION LISTENER OPERATIONS ---------- //
 	@Override
 	public void actionPerformed(ActionEvent e) {
@@ -85,7 +91,6 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 				}
 			}
 
-			
 			// If the text field is not empty
 			if (!messageContent.equals("")) {
 
@@ -99,7 +104,6 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 					e2.printStackTrace();
 				}
 
-				
 				try {
 					this.tcpClient.sendMessage(messageOut);
 				} catch (IOException e1) {
@@ -116,12 +120,16 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 
 		// If the button "Importer" is pressed
 		if ((JButton) e.getSource() == this.vue.getButtonImportFile()) {
+
 			// Display a file chooser to select one or several files
 			JFileChooser fc = new JFileChooser();
 			fc.setMultiSelectionEnabled(true);
 			int returVal = fc.showDialog(this.vue, "Importer");
 
-			
+			// If the user clicked on "Importer",
+			// Retrieve all the files he clicked on.
+			// The files are stored in this.files
+			// and their names are display in the ChatInput.
 			if (returVal == JFileChooser.APPROVE_OPTION) {
 				File[] files = fc.getSelectedFiles();
 				Collections.addAll(this.files, files);
@@ -136,8 +144,12 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 	}
 
 	
+	// ---------- KEY LISTENER METHODS ---------- //
+
 	@Override
-	public void keyTyped(KeyEvent e) {}
+	public void keyTyped(KeyEvent e) {
+	}
+
 	
 	@Override
 	public void keyPressed(KeyEvent e) {
@@ -149,21 +161,53 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 		}
 	}
 
+	
 	@Override
-	public void keyReleased(KeyEvent e) {}
+	public void keyReleased(KeyEvent e) {
+	}
 
 	
-	protected ArrayList<Message> getHistorique(){
+	// ---------- OTHERS ---------- //
+
+	/**
+	 * Create and send the message to ask for a file transfer.
+	 */
+	private void askFileTransfer() {
 		try {
-			ArrayList<Message> historique = this.sqlManager.getHistoriquesMessages(idOther, pseudoOther);
+			MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_INIT, "" + this.files.size(), "");
-			return historique;
+			this.tcpClient.sendMessage(messageOut);
-		} catch (SQLException e) {
+		} catch (MauvaisTypeMessageException | IOException e1) {
-			e.printStackTrace();
+			e1.printStackTrace();
-			return new ArrayList<Message>();
-			
 		}
 	}
 
+	
+	/**
+	 * Create and send the answer with the port on which the FileTransferServer is
+	 * listening.
+	 * 
+	 * @param port
+	 */
+	private void answerFileTransfer(int port) {
+		try {
+			MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_ANSWER, "" + port, "");
+			this.tcpClient.sendMessage(messageOut);
+		} catch (MauvaisTypeMessageException | IOException e1) {
+			e1.printStackTrace();
+		}
+	}
+
+	
+	/**
+	 * Retrieve the files' names from the given input using ";" as a separator
+	 * Removes the files whose names are missing.
+	 * 
+	 * This method is used to check if a file's name has been deleted/overwritten in
+	 * the ChatInput. Indeed, the only way to cancel the import of a file is by
+	 * deleting its name from the ChatInput.
+	 * 
+	 * @param input
+	 */
 	private void processSelectedFiles(String input) {
 		String[] tmp = input.split(";");
 		ArrayList<String> potentialFiles = new ArrayList<String>();
@@ -176,35 +220,64 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 		}
 	}
 
-	private void askFileTransfer() {
+	
+	/**
+	 * Retrieve the messages previously exchanged between the current user of the
+	 * application and the other user of this session
+	 * 
+	 * @return The ArrayList of all previous messages
+	 */
+	protected ArrayList<Message> getHistorique() {
 		try {
-			MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_INIT, ""+this.files.size(), "");
+			ArrayList<Message> historique = this.sqlManager.getMessageRecord(idOther, pseudoOther);
-			this.tcpClient.sendMessage(messageOut);
+			return historique;
-		} catch (MauvaisTypeMessageException | IOException e1) {
+		} catch (SQLException e) {
-			e1.printStackTrace();
+			e.printStackTrace();
+			return new ArrayList<Message>();
+
 		}
 	}
 
-	private void answerFileTransfer(int port) {
+	
+	/**
+	 * Method used when the session is over. Insert every message exchanged in the
+	 * database, set all attributes' references to null, and call destroyAll() on
+	 * the TCPClient.
+	 */
+	protected void destroyAll() {
+		String idSelf = Utilisateur.getSelf().getId();
+		String idOther = this.idOther;
+
 		try {
-			MessageFichier messageOut = new MessageFichier(TypeMessage.FICHIER_ANSWER, ""+port, "");
+			this.sqlManager.insertAllMessages(messagesOut, idSelf, idOther);
-			this.tcpClient.sendMessage(messageOut);
+			this.sqlManager.insertAllMessages(messagesIn, idOther, idSelf);
-		} catch (MauvaisTypeMessageException | IOException e1) {
+		} catch (SQLException e) {
-			e1.printStackTrace();
+			e.printStackTrace();
 		}
+
+		this.vue = null;
+		this.tcpClient.destroyAll();
+		this.tcpClient = null;
 	}
 
+	
+	// ---------- OBSERVERS ---------- //
+
 	// Method called when a message is received from the TCP socket
 	@Override
 	public void updateInput(Object o, Object arg) {
 		Message message = (Message) arg;
 
 		switch (message.getTypeMessage()) {
+
+		// If it is a simple text message, display it
 		case TEXTE:
 			System.out.println(message.toString());
 			this.vue.appendMessage(message);
 			this.messagesIn.add(message);
 			break;
+
+		// If it is an image, display a thumbnail
 		case IMAGE:
 			this.vue.appendImage(message);
 
@@ -214,6 +287,8 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 				this.messagesIn.add(message);
 			}
 			break;
+
+		// If it is a file, display a message saying whether it has been sent/received.
 		case FICHIER:
 			this.vue.appendMessage(message);
 
@@ -224,6 +299,10 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 			}
 			break;
 
+		// If it is a demand for a file transfer, create a new FileTransferServer, start
+		// it
+		// and answer back with "FICHIER_ANSWER" message containing the port of the
+		// server.
 		case FICHIER_INIT:
 			try {
 				MessageFichier mFichier = (MessageFichier) arg;
@@ -237,6 +316,10 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 				e.printStackTrace();
 			}
 			break;
+
+		// If it is an answer for a file transfer, create a FilteTransferClient
+		// with the port received and the path of the file(s) to send,
+		// and send the files.
 		case FICHIER_ANSWER:
 			try {
 				MessageFichier mFichier = (MessageFichier) arg;
@@ -266,23 +349,4 @@ public class ControleurSession implements ActionListener, ObserverInputMessage,
 		this.vue.endSession(this.pseudoOther);
 	}
 
-	/**
-	 * 
-	 */
-	protected void destroyAll() {
-		String idSelf = Utilisateur.getSelf().getId();
-		String idOther = this.idOther;
-		
-		try {
-			this.sqlManager.insertAllMessages(messagesOut, idSelf, idOther);
-			this.sqlManager.insertAllMessages(messagesIn, idOther, idSelf);
-		} catch (SQLException e) {
-			e.printStackTrace();
-		}
-		
-		this.vue = null;
-		this.tcpClient.destroyAll();
-		this.tcpClient = null;
-	}
-
 }

POO/src/session/VueSession.java

@@ -39,9 +39,6 @@ import messages.Message.TypeMessage;
 
 public class VueSession extends JPanel {
 
-	/**
-	 * 
-	 */
 	private static final long serialVersionUID = 1L;
 
 	private JButton sendMessage;
@@ -58,12 +55,7 @@ public class VueSession extends JPanel {
 		this.setBorder(new EmptyBorder(5, 5, 5, 5));
 		this.setLayout(new BorderLayout(0, 0));
 
-		this.chatInput = new JTextArea();
+		// Create the display zone
-		this.chatInput.setColumns(10);
-		this.chatInput.setLineWrap(true);
-		this.chatInput.setWrapStyleWord(true);
-		this.chatInput.addKeyListener(this.c);
-
 		this.chatWindow = new JTextPane();
 		this.chatWindow.setEditable(false);
 		this.chatWindow.setEditorKit(new WrapEditorKit());
@@ -71,21 +63,32 @@ public class VueSession extends JPanel {
 		JScrollPane chatScroll = new JScrollPane(this.chatWindow);
 		chatScroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
 
+		// Create the input zone
+		this.chatInput = new JTextArea();
+		this.chatInput.setColumns(10);
+		this.chatInput.setLineWrap(true);
+		this.chatInput.setWrapStyleWord(true);
+		this.chatInput.addKeyListener(this.c);
+
 		JPanel bottom = new JPanel();
 		bottom.setLayout(new BorderLayout(0, 0));
 
-		// remap "ENTER" to "none" to avoid "\n" in the input area after sending message
+		// Remap "ENTER" to "none" to avoid "\n" in the input area when pressing "ENTER"
+		// to send a message
 		KeyStroke enter = KeyStroke.getKeyStroke("ENTER");
 		this.chatInput.getInputMap().put(enter, "none");
 		KeyStroke shiftEnter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, KeyEvent.SHIFT_DOWN_MASK);
 		this.chatInput.getInputMap().put(shiftEnter, "insert-break");
 
-		this.importFile = new JButton("Importer..");
+		// Create a scroller to be able to send messages of several lines
-		this.importFile.addActionListener(this.c);
-
 		JScrollPane inputScroll = new JScrollPane(this.chatInput);
 		inputScroll.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
 
+		// Import file button
+		this.importFile = new JButton("Importer..");
+		this.importFile.addActionListener(this.c);
+
+		// Send message button
 		this.sendMessage = new JButton("Envoyer");
 		this.sendMessage.addActionListener(this.c);
 
@@ -93,6 +96,7 @@ public class VueSession extends JPanel {
 		bottom.add(inputScroll, BorderLayout.CENTER);
 		bottom.add(this.sendMessage, BorderLayout.EAST);
 
+		// Add the components to the view
 		this.add(chatScroll, BorderLayout.CENTER);
 		this.add(bottom, BorderLayout.SOUTH);
 
@@ -102,32 +106,30 @@ public class VueSession extends JPanel {
 
 	}
 
+	// -------------- GETTERS -------------- //
+
 	protected JButton getButtonEnvoyer() {
 		return this.sendMessage;
 	}
 
+	
 	protected JButton getButtonImportFile() {
 		return this.importFile;
 	}
 
+	
 	protected String getInputedText() {
 		return this.chatInput.getText();
 	}
 	
-	protected void appendInputedText(String str) {
-		this.chatInput.append(str);
-	}
 
+	// -------------- DISPLAY METHODS -------------- //
 
-	protected void resetZoneSaisie() {
+	/**
-		this.chatInput.setText("");
+	 * Append the given string to the ChatWindow.
-		
+	 * 
-	}
+	 * @param str
-
+	 */
-	private void setCaretToEnd() {
-		this.chatWindow.setCaretPosition(this.chatWindow.getDocument().getLength());
-	}
-	
 	protected void appendString(String str) {
 		try {
 			Document doc = this.chatWindow.getDocument();
@@ -137,12 +139,16 @@ public class VueSession extends JPanel {
 		}
 	}
 
+	
+	/**
+	 * Append the given Message to the ChatWindow.
+	 * 
+	 * @param message
+	 */
 	protected void appendMessage(Message message) {
 
 		try {
 			StyledDocument sdoc = this.chatWindow.getStyledDocument();
-			// sdoc.setParagraphAttributes(sdoc.getLength(), message.toString().length()-1,
-			// style, false);
 			sdoc.insertString(sdoc.getLength(), message.toString(), null);
 
 		} catch (BadLocationException e) {
@@ -150,6 +156,14 @@ public class VueSession extends JPanel {
 		}
 	}
 
+	
+	/**
+	 * Append an icon with the image contained in the given message. The message has
+	 * to contain the base64 encoded bytes of the image as a String for it to be
+	 * decoded and displayed.
+	 * 
+	 * @param message
+	 */
 	protected void appendImage(Message message) {
 		this.setCaretToEnd();
 
@@ -165,22 +179,40 @@ public class VueSession extends JPanel {
 			e.printStackTrace();
 		}
 
-		
 	}
 
+	
 	private void printLineSeparator() {
 		this.appendString("------------------------------------------\n");
 	}
 
-	protected void endSession(String pseudoOther) {
+	/**
-		this.printLineSeparator();
+	 * Append the given string to the ChatInput.
-		this.appendString(pseudoOther + " a mis fin à la session.");
+	 * 
-		this.chatInput.setEnabled(false);
+	 * @param str
-		this.chatInput.setFocusable(false);
+	 */
-		this.sendMessage.setEnabled(false);
+	protected void appendInputedText(String str) {
-		this.importFile.setEnabled(false);
+		this.chatInput.append(str);
 	}
 
+	
+	protected void resetZoneSaisie() {
+		this.chatInput.setText("");
+
+	}
+
+	
+	// -------------- OTHERS -------------- //
+
+	private void setCaretToEnd() {
+		this.chatWindow.setCaretPosition(this.chatWindow.getDocument().getLength());
+	}
+
+	
+	/**
+	 * Retrieve all the previous messages from the controller and display them by
+	 * appending them one by one to the ChatWindow.
+	 */
 	private void displayHistorique() {
 		ArrayList<Message> historique = this.c.getHistorique();
 
@@ -197,6 +229,27 @@ public class VueSession extends JPanel {
 		}
 	}
 
+	
+	/**
+	 * Disable the ChatInput, the buttons "Importer" and "Envoyer" and display a
+	 * message indicating the other user ended the session.
+	 * 
+	 * @param pseudoOther
+	 */
+	protected void endSession(String pseudoOther) {
+		this.printLineSeparator();
+		this.appendString(pseudoOther + " a mis fin à la session.");
+		this.chatInput.setEnabled(false);
+		this.chatInput.setFocusable(false);
+		this.sendMessage.setEnabled(false);
+		this.importFile.setEnabled(false);
+	}
+
+	
+	/**
+	 * Method used when the user closes the session. Set all attributes' references
+	 * to null, and call destroyAll() on the controller.
+	 */
 	public void destroyAll() {
 		if (this.c != null) {
 			this.c.destroyAll();
@@ -207,6 +260,7 @@ public class VueSession extends JPanel {
 		this.sendMessage = null;
 	}
 
+	
 	// ------------- PRIVATE CLASS TO WRAP TEXT -------------//
 
 	class WrapEditorKit extends StyledEditorKit {