Java[tm] Platform Chat Application

public class MultiChat extends JPanel implements ActionListener {

    // variable declarations

    private void send(String msg) throws IOException {

                // Get an instance of the current date/time.

                // Create a string buffer to contain the current timestamp, the user id and message strings

                // Create an array of bytes from the string buffer

                // Convert the array of bytes to  a datagram packet and send it out to the opened socket connection

    class Reader extends Thread {

                // Create the implementation for the run() method.

                // Instantiate an array of 512 byte elements and a datagram packet object set to null.

                // Using a while loop, using the receive() method of the MulticastSocket, listen for any packet that may be sent for a hosts within
                   the host group.

                // If a packet is detected, extract the string text and append it to the text area to display the message.

     }

    MultiChat(String name) {

                // Create an internet socket address of a multicast address and port number of choice. Use the default network interface that is on the local host
                    machine.  Create a multicast socket bound to the correct port and use the joinGroup() method to make the multicast socket join the selected
                    multicast group.

                // Create the GUI for this chat application. Use the setLookAndFeel() from the UIManager class to force the swing components to come up
                    with cross platform look and feel.

                // Use the Border layout for the GUI. Create an area where the text string messages will be seen when a RETURN is hit. This is done with a
                   JTextArea component placed in the center of the JFrame layout. Create an area in which the sender can type the text string
                    messages to sent to the network after the RETURN is hit. This is achieved with a JTextField component placed at the bottom of the JFrame
                    layout.

                // Start the Reader thread

    }

    public void actionPerformed(ActionEvent evt) {

                // Check the text in the text field area. Test the text and if it matches the word "Quit" ignoring the case, then exit the program. Otherwise call the
                   send() method implemented above to send the message out over the multicast socket connection.

                // Finally, clear the text field.

    }

    protected static final class AppCloser extends WindowAdapter {

                // Implement the windowClosing() method to exit the program when the window is closed by the user

    }

    public static void main(String[] args) {

                // Set the id of the chat user to "Anonymous" if there is no argument provided when the program is run from the command line. Otherwise, take the
                    first argument as the users' chat id.

                // Create a JFrame with Border layout and add the MultiChat GUI onto the center. Use a JLabel and indicate to the user how to quit/exit the application
                    and place it at the bottom of the frame.

                // Add the window listener with AppCloser()  to this frame.

                // Size the frame appropriately and display the JFrame.

}

SECTION C - Solution Source

/*
 * Multicast based chat system with a very simple GUI using SWING
 * The main thread does the sending, while a secondary thread (the reader)
 * does the receiving of messages
 */

public class MultiChat extends JPanel implements ActionListener {

    JTextArea textarea = null;
    JTextField textfield = null;
    JScrollPane scrollpane = null;
    private String id;
    private MulticastSocket socket = null;
    private SocketAddress dest = null;

    /**
     * Send the text to the multicast group.
     * Add the name of the user in front of the message.
     */
    private void send(String msg) throws IOException {
        Calendar now = Calendar.getInstance();
        String buf = "[" + now.getTime().toString() + "] " + id + ": " + msg;
        byte[] b = buf.getBytes();
        DatagramPacket packet = new DatagramPacket(b, 0, b.length, dest);
        socket.send(packet);
    }

    /**
     * Reader thread.
     */
    class Reader extends Thread {
        public void run() {
            byte[] buf = new byte[512];
            DatagramPacket p = null;
            // Just loop forever, as the main thread will take care of the
            // exit conditions
            while (true) {
                try {
                    p = new DatagramPacket(buf, buf.length);
                    socket.receive(p);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                // We got a packet, let's extract the message and display it
                String line = new String(p.getData(), 0, p.getLength());
                textarea.append(line);
                textarea.append("\n");
            }
        }
    }

    /**
     * Main constructor.
     * Takes a String containing the name (or id) of the user.
     */
    MultiChat(String name) {

        super(true);
        id = name;

        // This is the multicast group we'll be using.
        dest = new InetSocketAddress("228.5.6.7", 4321);

        try {
            // The socket is created and bound to the proper port.
            socket = new MulticastSocket(4321);
            // Set the loopback mode to false if you don't want to see your
            // own messages
            // socket.setLoopbackMode(false);

            // get the default Network Interface
            NetworkInterface netif = NetworkInterface.getByInetAddress(InetAddress.getLocalHost());
            // Join the multicast group
            socket.joinGroup(dest, netif);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }

        // From here onwards, the GUI is created

        // Force SwingSet to come up in the Cross Platform L&F
        try {
            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
            // If you want the System L&F instead, comment out the above line and
            // uncomment the following:
            // UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (Exception exc) {
            System.err.println("Error loading L&F: " + exc);
        }

        setBorder(BorderFactory.createEtchedBorder());
        setLayout(new BorderLayout());
        setFocusCycleRoot(true);
        setRequestFocusEnabled(true);

        // Create the area in which the messages will be seen after a RETURN is hit.
        // Using the JTextArea class to construct the GUI for this purpose.
        textarea = new JTextArea();
        textarea.setBackground(Color.cyan);
        textarea.setLineWrap(true);
        textarea.setWrapStyleWord(true);
        textarea.setEditable(false);
        scrollpane = new JScrollPane(textarea);
        scrollpane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);

        // Create the area in which the user can key in the text message to be displayed.
        // Using the JTextField class to construct the GUI for this purpose.
        textfield = new JTextField();
        textfield.setBackground(Color.yellow);
        textfield.setDragEnabled(true);
        textfield.requestFocus(true);

        add("Center", scrollpane);
        add("South", textfield);

        textfield.addActionListener(this);
        Reader r = new Reader();
        r.start();
    }

    // When the user hits <RETURN> this method is called
    public void actionPerformed(ActionEvent evt) {
        String text = textfield.getText();
        try {

            // So you want to quit?
            if ("quit".equalsIgnoreCase(text)) {
                // Let's be nice
                send("Goodbye!");
                System.exit(1);
            }

            // OK, let's just send the message then
            send(text);

            // And clear the TextField
            textfield.setText("");

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    /**
     * To shutdown when run as an application.  This is a
     * fairly lame implementation.   A more self-respecting
     * implementation would at least check to see if a save
     * was needed.
     */

    protected static final class AppCloser extends WindowAdapter {

        public void windowClosing(WindowEvent e) {
            System.exit(0);
        }

    }

    /**
     * main() method of this program. The method creates a frame with Border Layout
     * and adds the MultiChat GUI onto the center of the frame with text string as
     * a label on the bottom of the frame to inform the user how to quit the application.
     */

    public static void main(String[] args) {

        String name = "Anonymous";
        if (args.length > 0)
            name = args[0];
        JFrame frame = new JFrame();
        frame.setTitle(name + "@ChatRoom");

        // Add the comps...
        frame.getContentPane().setLayout(new BorderLayout());
        frame.getContentPane().add("Center", new MultiChat(name));
        frame.getContentPane().add("South", new JLabel("Type \'quit\' to exit or just close the window"));
        frame.addWindowListener(new AppCloser());
        frame.pack();
        frame.setSize(600, 200);
        frame.show();

    }

}

Doc ID #824