Server.java

/*
 * Le Tan Loc B1605339
 */
package Server;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Server {

    public final static int FILE_SIZE = 102400000;

    public static ServerChatThread[] serverChatThread = new ServerChatThread[5];
    public static ServerFileThread serverFileThread[] = new ServerFileThread[5];

    private static int clientNumber = 0;

    public static void main(String args[]) throws IOException {

        ServerSocket listenerChat = null;
        ServerSocket listenerFile = null;

        System.out.println("Server is waiting to accept user...");

        // Mở một ServerSocket tại cổng 9999 9998.
        // Chú ý bạn không thể chọn cổng nhỏ hơn 1023 nếu không là người dùng
        // đặc quyền (privileged users (root)).
        try {
            listenerChat = new ServerSocket(9999);
            listenerFile = new ServerSocket(9998);
        } catch (IOException e) {
            System.out.println(e);
            System.exit(1);
        }

        try {
            while (true) {

                // Chấp nhận một yêu cầu kết nối từ phía Client.
                // Đồng thời nhận được một đối tượng Socket tại server.
                Socket socketChatServer = listenerChat.accept();
                Socket socketFileServer = listenerFile.accept();
                serverChatThread[clientNumber] = new ServerChatThread(socketChatServer, clientNumber);
                serverChatThread[clientNumber].start();
                serverFileThread[clientNumber] = new ServerFileThread(socketFileServer, clientNumber);
                serverFileThread[clientNumber].start();
                clientNumber++;
            }
        } finally {
            listenerChat.close();
        }

    }

    public synchronized static int getClientNumber() {
        //System.out.println("client number " + Server.clientNumber);
        return clientNumber;
    }

    private static void log(String message) {
        System.out.println(message);
    }

    private static class ServerChatThread extends Thread {

        private int clientNumber;
        private Socket socketChatServer;
        BufferedReader is;
        BufferedWriter os;

        public ServerChatThread(Socket socketChatServer, int clientNumber) {
            this.clientNumber = clientNumber;
            this.socketChatServer = socketChatServer;

            // Log
            log("New connection with client# " + this.clientNumber + " at " + socketChatServer);
        }

        public void send(String chat) {
            try {
                //Le Tan Loc B1605339
                // Ghi vào luồng đầu ra của Socket tại Server.
                // (Nghĩa là gửi tới Client).
                os.write(chat); // Kết thúc dòng
                os.newLine();   // Đẩy dữ liệu đi
                os.flush(); //Le Tan Loc B1605339 
            } catch (IOException ex) {
                Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
            }
        }

        @Override
        public void run() {

            try {
                //Mở luồng vào ra trên Socket tại Server.
                is = new BufferedReader(new InputStreamReader(socketChatServer.getInputStream()));
                os = new BufferedWriter(new OutputStreamWriter(socketChatServer.getOutputStream()));
                while (true) {

                    // Đọc dữ liệu tới server (Do client gửi tới).
                    String line = is.readLine();
                    System.out.println("log " + line);
                    for (int i = 0; i < Server.getClientNumber(); i++) {
                        if (i != this.clientNumber) {
                            System.out.println("thread " + i);
                            Server.serverChatThread[i].send(this.clientNumber + " " + line);
                        }
                    }

                    //Đóng kết nối
                    //is.close();
                    //os.close();
                    //Le Tan Loc B1605339
                }
            } catch (IOException e) {
                System.out.println(e);
                e.printStackTrace();
            }
        }
    }

    private static class ServerFileThread extends Thread {

        private Socket socketFileServer;
        private int clientNumber;

        public ServerFileThread(Socket socketFileServer, int clientFileNumber) {
            this.socketFileServer = socketFileServer;
            this.clientNumber = clientFileNumber;
        }

        public void send(byte[] mybytearray, int current, String fileName) throws IOException {
            OutputStream os = null;
            //locb1605339 send file name
            BufferedWriter osBw = null;

            try {
                osBw = new BufferedWriter(new OutputStreamWriter(socketFileServer.getOutputStream()));
            } catch (IOException ex) {
                Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
            }

            try {
                osBw.write(fileName); // Ghi dữ liệu vào luồng đầu ra của Socket tại Client.
                osBw.newLine();   // kết thúc dòng
                osBw.flush();     // đẩy dữ liệu đi.
                osBw.write(Integer.toString((int) current)); // Ghi dữ liệu vào luồng đầu ra của Socket tại Client.
                osBw.newLine();   // kết thúc dòng
                osBw.flush();     // đẩy dữ liệu đi.
            } catch (IOException ex) {
                Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
            }

            try {
                // send file

                os = socketFileServer.getOutputStream();
                TimeUnit.SECONDS.sleep(1);
                os.write(mybytearray, 0, current);
                os.flush();
                System.out.println("Send " + fileName + "(" + current + " bytes)");
                System.out.println("Done.");
            } catch (FileNotFoundException ex) {
                Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IOException ex) {
                Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InterruptedException ex) {
                Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
            }
            System.out.println("Function send finish mybytearray: " + current);
        }

        @Override
        public void run() {
            while (true) {
                try {
                    //locb1605339 Get file name
                    BufferedReader isBr = new BufferedReader(new InputStreamReader(socketFileServer.getInputStream()));
                    String fileClientName = null;
                    while ((fileClientName = isBr.readLine()) != null) {
                        System.out.println("fileClientName: " + fileClientName);
                        int fileSize = Integer.parseInt(isBr.readLine());
                        System.out.println("FileSize: " + fileSize);

                        String fileName = new Date().getTime() + fileClientName;

                        byte[] mybytearray = new byte[fileSize]; //Read file in there
                        InputStream is = socketFileServer.getInputStream();
                        is.read(mybytearray, 0, mybytearray.length);
                        System.out.println("Length: " + mybytearray.length);

                        for (int i = 0; i < 10; i++) {
                            if (mybytearray[i] != 0) {
                                System.out.println("String " + i + " : " + mybytearray[i]);
                            }
                        }
                        for (int i = 0; i < Server.getClientNumber(); i++) {
                            if (i != this.clientNumber) {
                                System.out.println("thread " + this.clientNumber + " send thread " + i);
                                Server.serverFileThread[i].send(mybytearray, fileSize, fileName);
                            }
                        }
                        fileClientName = null;
                        break;
                    }
                } catch (IOException ex) {
                    Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
    }
}