keep socket connection open after transfering a file to a client java

Question 1

In order to implement what you are asking, you need to establish a communication protocol that the server and client understand. Something needs to be transmitted that says, "I'm starting to send information to you," and something that says, "I'm done sending stuff." There could be more -- such as information delimiting (e.g. Mime multipart form boundary). But at a minimum, you need the start and stop tokens.

Expanding on that: Look at the code in its simplest form: server:loop{write()} -> client:loop{read()}. Closing the stream on the server-side sends the -1 value to the client, which is usually consumed as the stop signal. If you want to maintain the connection indefinitely, and write to the client at different times, something has to be sent that says, "This transaction is complete". The following is pseudo-ish code -- freehand, not compiled.

// SERVER
private Socket socket; // initialized somewhere

private static final byte[] STOP = "</COMMS>".getBytes();

public void sendData(byte[] bytes) throws IOException{

  OutputStream out = socket.getOutputStream();

  if(bytes != null){
      out.write(bytes,0,bytes.length);
  }

  out.write(STOP);
}  // notice we exit the method without closing the stream.

// CLIENT
private Socket socket; // initialized somewhere
private static final byte[] STOP = "</COMMS>".getBytes();
private static final int BUFFER_SIZE = 1024 << 8;
private InputStream in;

public byte[] receiveData(){
    if(in == null){
      in = socket.getInputStream();
    }
    byte[] content;
    byte[] bytes = new byte[BUFFER_SIZE];
    int bytesRead;
    while((bytesRead = in.read(bytes)) != -1){  // normal termination
          if(receivedStop(bytes,bytesRead)){  // see if stopped
               removeStopBytes(bytes,bytesRead); // get rid of the STOP bytes
               content = buildContent(content,bytes,bytesRead); // transfer bytes to array
               break;
          }
          content = buildContent(content,bytes,bytesRead); // transfer bytes to array
    }
    return content;
}

Again, that was freehand and not compiled or tested. I'm sure it's not fully correct but hopefully you get the gist. The server writes content but never closes the stream. The client reads the stream looking for the STOP content, building up the final content until the stop is reached.

Question 2

Thanks to madConan for the reply, it gave me a good idea of how to do it. I will post my code here, so others can use it in future.

SERVER CODE

    public void run() {
    try {
        PrintStream outToClient = new PrintStream(connection.getOutputStream());
        OutputStream os = connection.getOutputStream();
        BufferedInputStream input = new BufferedInputStream(new FileInputStream(f));
        outToClient.println("file");
        copy(input, os, f);
        System.out.println(connection.isClosed());
    } catch (IOException ex) {
        Logger.getLogger(SocketController.class.getName()).log(Level.SEVERE, null, ex);
    }
}

private static void copy(final InputStream is, final OutputStream os, File f) throws         IOException {
    final byte[] stop = "stop".getBytes();
    final byte[] buffer = new byte[(int) f.length()];
    is.read(buffer, 0, buffer.length);
    os.write(buffer, 0, buffer.length);
    os.write(stop);
    os.flush();
}

CLIENT CODE

    public static File recieveData(Socket clientSocket, File f) {
    try {
        InputStream in = clientSocket.getInputStream();
        FileOutputStream output = new FileOutputStream(f);
        byte[] content;
        byte[] bytes = new byte[1024 << 8];
        int bytesRead;
        while (true) {
            if (recieveStop(f)) {
                removeStop(f);
                break;
            }
            bytesRead = in.read(bytes);
            output.write(bytes, 0, bytesRead);
        }
    } catch (IOException ex) {
        Logger.getLogger(Master_Slave_Sockets_Client.class.getName()).log(Level.SEVERE, null, ex);
    }
    return f;
}

public static boolean recieveStop(File f) {
    BufferedReader br = null;
    try {
        br = new BufferedReader(new FileReader(f));
        String currentLine;
        String lastLine = "";
            while ((currentLine = br.readLine()) != null) {
                lastLine = currentLine;
            } 
        if (lastLine.equals("stop")) {
            return true;
        }
    } catch (FileNotFoundException ex) {
        Logger.getLogger(Master_Slave_Sockets_Client.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IOException ex) {
            Logger.getLogger(Master_Slave_Sockets_Client.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
        try {
            br.close();
        } catch (IOException ex) {
            Logger.getLogger(Master_Slave_Sockets_Client.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    return false;
}

public static void removeStop(File f) {
    try {
        RandomAccessFile raFile = new RandomAccessFile(f, "rw");
        long length = raFile.length();
        raFile.setLength(length - 4);
        raFile.close();
    } catch (FileNotFoundException ex) {
        Logger.getLogger(Master_Slave_Sockets_Client.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IOException ex) {
        Logger.getLogger(Master_Slave_Sockets_Client.class.getName()).log(Level.SEVERE, null, ex);
    }

}

Hope this will help others with the same problem.