COO-farina-vincent/src/chat/NetworkClient.java

package chat;

import java.net.*;

import javax.swing.*;

import java.awt.*;
import java.util.List;
import java.awt.event.*;

import java.io.*;
import java.util.*;

import chat.User;
import chat.Message;

public class NetworkClient {
	 private User user;
	 private List<User> known_users;
	 private List<User> known_outdoor_users;
	 private List<Socket> dest_sockets;
	 private List<Socket> outdoor_dest_sockets;
	 private JTextArea chatText;
	 private JTextArea knownUsersPanel;
		
	static 	String getLocalIP() {
		String ip = "";
		try(final DatagramSocket socket = new DatagramSocket()){
			  socket.connect(InetAddress.getByName("8.8.8.8"), 10002);
			  ip = socket.getLocalAddress().getHostAddress();
			}
			catch(Exception e)
			{
				System.out.println("niiiiiiiikkk");
			}
		return ip;
	}
	
	NetworkClient(JTextArea in_chatText, JTextArea in_knownUsersPanel)
	{
		user = new User("");
		chatText = in_chatText;
		knownUsersPanel = in_knownUsersPanel;
		known_users = new ArrayList<User>();
		known_outdoor_users = new ArrayList<User>();
		dest_sockets = new ArrayList<Socket>();
		outdoor_dest_sockets = new ArrayList<Socket>();
	}
	
	boolean connect(String username, Boolean outdoor, String destinationIP)
	{
      boolean nameAvailable = true;
      boolean connected = false;
      DatagramSocket connectionSocket;
      DatagramSocket userListSocket;
      
      DatagramPacket connectionRequest;
      DatagramPacket responsePacket;
      
      String[] usernameList;
      String[] outdoorUsernameList;
      String[] addressList;
            
      int portNumber = 1237;
      byte[] buffer1 = new byte[20000];
      
      if(username == null || username.compareTo("") == 0)
    	  return false;

      try
      { 
            try
            { 
            	if(!outdoor)
            	{
            		connectionSocket = new DatagramSocket();
    	            userListSocket = new DatagramSocket(1337);
    	            
    	            userListSocket.setSoTimeout(500);
    	            	
    	            connectionRequest = new DatagramPacket(username.getBytes(), username.length(),
    	            													InetAddress.getByName(destinationIP), 1234);
    	            /*l'adresse de broadcast est hardcodée ici
    	            pour tester avec Hamachi, il faut la remplacer par celle du réseau local virtuel*/
    	            System.out.println("Sending connection request");
    	            connectionSocket.send(connectionRequest);
    	            
            		responsePacket = new DatagramPacket(buffer1, buffer1.length);
	            	
	            	System.out.println("Waiting for reply");
	            	userListSocket.receive(responsePacket);
	            	System.out.println("Received a reply from " + responsePacket.getAddress().getHostAddress());
	                
	            	String[] response = new String(responsePacket.getData()).trim().split(";");	
	            	
	            	usernameList = response[0].split(" ");
	            	outdoorUsernameList = response[1].split(" ");
	            	addressList = response[2].split(" ");
	                portNumber = Integer.parseInt(response[3]);
	                
	                connectionSocket.close();
		            userListSocket.close();
            	}
                else
	          	{
	          		  Socket requestSocket = new Socket(destinationIP, 1233);
	          		  BufferedReader in = new BufferedReader(new InputStreamReader(requestSocket.getInputStream()));
	          		  PrintWriter out = new PrintWriter(requestSocket.getOutputStream(), true);
	          		  out.println(username);
	          		  String[] response = in.readLine().split(";");
	          		  usernameList = response[0].split(" ");
		              outdoorUsernameList = response[1].split(" ");
	          		  addressList = new String[0];
	                  portNumber = Integer.parseInt(response[2]);
	          	}
            	
            	for(String u:usernameList)
            	{		
            		nameAvailable = nameAvailable && (!username.equals(u));
            	}
            	if(nameAvailable)
            	{
            		System.out.println(usernameList.length + " users currently connected");
            		for(String u:usernameList)
                	{
                		known_users.add(new User (u));
                	}
            		for(String u:outdoorUsernameList)
                	{
                		known_outdoor_users.add(new User (u));
                	}
            		for(String a:addressList)
                	{
            			Socket s = new Socket(a, portNumber);
                		dest_sockets.add(s);
            			(new ReceiveThread(user, s, chatText, known_users, known_outdoor_users, knownUsersPanel, dest_sockets, outdoor_dest_sockets, false)).start();
                	}
					Collections.sort(known_users);
            		connected = true;
            	}
            }
          	catch(SocketTimeoutException e)
           //Si on est tout seul sur le réseau (on ne reçoit aucune réponse)
            {
          		System.out.println("Reply timed out");
          		connected = true;
            }
      }
      catch (SocketException e2)
      {
    	  	e2.printStackTrace();
      }
      catch (Exception e3)
      {
      		e3.printStackTrace();
      }
      
      if(connected)
      {
          if(!outdoor)
          {
        	  (new ConnectionListenerThread(user, known_users, known_outdoor_users, dest_sockets, outdoor_dest_sockets, chatText, knownUsersPanel, portNumber)).start();
        	  (new OutdoorListenerThread(user, known_users, known_outdoor_users, dest_sockets, outdoor_dest_sockets, chatText, knownUsersPanel)).start();
	          
	          try
	          {
	        	  	ServerSocket s1 = new ServerSocket(portNumber);
	        	  	(new ListenerStartThread(s1, dest_sockets)).start();
	        	  	
	        	  	Socket s2 = new Socket(getLocalIP(), portNumber);
	        	  	System.out.println(getLocalIP());
	        	  	/*Attention, getLocalIP ne marche que sur un même réseau physique
	        	  	 * pour tester avec Hamachi, il faut hardcoder les IP
	        	  	 */
		  			(new ReceiveThread(user, s2, chatText, known_users, known_outdoor_users, knownUsersPanel, dest_sockets, outdoor_dest_sockets, false)).start();
	          }
	          catch(IOException e)
	          {
	        	  e.printStackTrace();
	          }
          }
          else
          {
        	  try
        	  {
        		  Socket s = new Socket(destinationIP, portNumber);
            	  dest_sockets.add(s);
		  		  (new ReceiveThread(user, s, chatText, known_users, known_outdoor_users, knownUsersPanel, dest_sockets, outdoor_dest_sockets, false)).start();
        	  }
        	  catch(IOException e)
	          {
	        	  e.printStackTrace();
	          }
          }
          
          user.setName(username);
          
          send(new ConnectNotification(user, false, outdoor));
      }
      
      return connected;
	}
	
	void send (Notification notif)
	{
		for(Socket s:dest_sockets)
		{
			try
			{
				//System.out.println(s.getInetAddress().getHostAddress() + ": local port " + s.getLocalPort() + ", remote port " + s.getPort());
				ObjectOutputStream out = new ObjectOutputStream(s.getOutputStream());
			    out.writeObject(notif);
			}
			catch(IOException e){}
		}
		for(Socket s:outdoor_dest_sockets)
    	{
    		try
    		{
    			//System.out.println(s.getInetAddress().getHostAddress() + ": local port " + s.getLocalPort() + ", remote port " + s.getPort());
    			ObjectOutputStream out = new ObjectOutputStream(s.getOutputStream());
			    out.writeObject(notif);
    		}
    		catch(IOException e){}
    	}
	}
	
	void disconnect()
	{
		send(new DisconnectNotification(user, false));
		try
		{
			Thread.sleep(1000);
		}
		catch(InterruptedException e) {}
		
		for(Socket s:dest_sockets)
		{
			try
			{
				s.close();
			}
			catch(IOException e){}
		}
	}
	
	User getUser()
	{
		return user;
	}
}