Chat application in J2ME

Hi, friends 🙂 Today I am going to implement a chat application. Using this application you can chat each other if the two devices are in a same network. Actually the full application contains Chat Server and Chat Client. When one device runs the Chat Server application, another device can connect to that previous device by using Chat Client application. Here I am mentioning another important tool for developers. It is about GitHub a Version Control System.  I have used it to host my source code because if I am going to put all the source code with in this post it is going to be the lengthiest post ever 😉

The classes that I have used newly in this application but not in my previous applications are,

• DataInputStream
• DataOutputStream
• Font
• InputStream
• InterruptedException
• OutputStream
• StringBuffer
• StringItem

The interfaces that you will come across newly in these source codes are,

• ServerSocketConnection
• SocketConnection

Figure 1

Let’s understand the scenario using the images. To chat, you need to devices. In my previous post I have shown you how to get two devices with your emulator. After you load the project, you can see two applications as in Figure 1.

First you have to run the Chat Server application (Figure 2). Because client need a running server to connect. When you are installed this application in to your mobile phone, make

Figure 2

sure you connect to a same network. The reason is, we are going to connect devices each other by the device IP address.

In the initial interface of the Chat Server application you can see two Items. They are StringItem and a Gauge. To run the server, press the Start command on the screen. Then it will display the device IP address as in Figure 3. Still you no need to run the Chat Client application.

Figure 3

If you are not in an identified network the IP address you will get is 127.0.0.1 which means localhost. After you getting the server IP address, start the Chat Client application.

As the initial interface of the client application, you will be provided a space to type and sent the server IP address. That means you sent a request to the running chat server, that you want to connect to the opened port for initialize a chat. This

Figure 4

is a socket connection. You met a sms connection in the “send and receive SMS” blog post. Try to identify the differences by looking at the Connection String.

Figure 4 shows you the way that client enter the server IP address and sending the request to the server by pressing Connect command. When the chat client and chat server

Figure 5

connect each other successfully, you get Alert messages on both devices as in Figure 5.  Now connections are ready and you also ready to chat 🙂 Figure 6 shows the chatting interfaces of both client and server applications.

Anyone can start the chat because Alert message confirms that you two are connected. In my scenario, client starts the

Figure 6

chat. So he types something in the given TextField and press the Send command as in Figure 7.

Then you can see the text sent by other party right below your TextField as in Figure 8. Next the server can send a reply to the client. Do these methods as long as you wish. 😉 I have restricted the characters amount in one message to 160.

Figure 7

Therefore you cannot sent more that 160 characters in a single chat.

I did not handle the exceptions in this application. As an example I assume the client send the correct IP address that server shows in his screen. This complete application contains four files so I do not want to complex the code more. Another

Figure 8

thing I have done in the source is, showing the exceptions that could throw by methods in separately. I did that for learning purposes only. You can reduce the complexity of the code by putting all the exceptions in to one block.

Now it is better to jump to the source code. Here I have shown you just the Chat Server’s code. Other files I have uploaded to the GitHub and you can download them from there.

package anuMidSub;

import anuThreadSub.MessageReceiver;
import anuThreadSub.MessageSender;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import javax.microedition.io.Connector;
import javax.microedition.io.ServerSocketConnection;
import javax.microedition.io.SocketConnection;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Gauge;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.ItemCommandListener;
import javax.microedition.lcdui.Spacer;
import javax.microedition.lcdui.StringItem;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;

/**
 * @author Anuja
 */
public class ChatServer extends MIDlet implements CommandListener, ItemCommandListener, Runnable {
    private Display display;
    private Form chatServerForm;
    private Command exitCmd;
    private StringItem ipStrItem;
    private StringItem startServerStrItem;
    private Command startCmd;
    private Form showIpForm;
    private Gauge gaugeItem;
    private Spacer spacerItem;
    private ServerSocketConnection serSocCon;
    private String deviceIp;
    private SocketConnection socCon;
    private DataInputStream is;
    private DataOutputStream os;
    private Form srvChattingFrm;
    private TextField chatTxtFld;
    private Alert infoAlert;
    private Command sendCmd;
    private String srvChatMsg;
    private MessageSender msgSenderClass;

    public void startApp() {
        display = Display.getDisplay(this);

        //-------------------------- Start chat server form --------------------
        chatServerForm = new Form("Chat Server");

        // \t use for getting tab space
        startServerStrItem = new StringItem("Start Chat Server \t", "Start", Item.BUTTON);
        chatServerForm.append(startServerStrItem);

        startCmd = new Command("Start", Command.ITEM, 8);
        startServerStrItem.setDefaultCommand(startCmd);
        startServerStrItem.setItemCommandListener(this);

        // Provide space as developer defined minWidth and minHeight
        spacerItem = new Spacer(200, 50);
        chatServerForm.append(spacerItem);

        // Continuous-running state of a non-interactive Gauge with indefinite range
        gaugeItem = new Gauge("Waiting for client... \n", false, Gauge.INDEFINITE, Gauge.CONTINUOUS_RUNNING);
        // Set layout position for this gauge item
        gaugeItem.setLayout(Item.LAYOUT_CENTER);
        chatServerForm.append(gaugeItem);

        exitCmd = new Command("Exit", Command.EXIT, 7);
        chatServerForm.addCommand(exitCmd);

        chatServerForm.setCommandListener(this);
        display.setCurrent(chatServerForm);

        // ----------------------- Show IP form --------------------------------

        showIpForm = new Form("Chat Server");
        ipStrItem = new StringItem("Client must connect to this IP: \n\n", "My IP \n");
        ipStrItem.setLayout(Item.LAYOUT_CENTER);

        // setFont() sets the application's preferred font for rendering this StringItem.
        ipStrItem.setFont(Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_LARGE));
        showIpForm.append(ipStrItem);

        showIpForm.addCommand(exitCmd);
        showIpForm.setCommandListener(this);

        //------------------- Server chatting form -----------------------------

        srvChattingFrm = new Form("Server Chatting...");
        chatTxtFld = new TextField("Enter Chat", "", 160, TextField.ANY);
        srvChattingFrm.append(chatTxtFld);

        sendCmd = new Command("Send", Command.OK, 4);
        srvChattingFrm.addCommand(sendCmd);
        srvChattingFrm.addCommand(exitCmd);
        srvChattingFrm.setCommandListener(this);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

    public void commandAction(Command c, Displayable d) {
        if(c == exitCmd){
            notifyDestroyed();
        }else if(c == sendCmd){
            // getString() gets the contents of the TextField as a string value.
            srvChatMsg = chatTxtFld.getString();
            // Send the chat to send() in MessageSender class
            msgSenderClass.send(srvChatMsg);
        }
    }

    public void commandAction(Command c, Item item) {
        if(c == startCmd){
            new Thread(this).start();
            //Alert alert = new Alert("Working");
            //display.setCurrent(alert);
        }
    }

    public void run() {
        System.out.println("Runnig");
        try {
            // ServerSocketConnection interface defines the server socket stream connection.
            // Create the server listening socket for port 60000
            serSocCon = (ServerSocketConnection) Connector.open("socket://:60000");
            System.out.println("Open the socket...");
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        try {
            // Gets the local address to which the socket is bound.
            // The host address(IP number) that can be used to connect to this end of the socket connection from an external system.
            deviceIp = serSocCon.getLocalAddress();
            System.out.println("Get device IP...");
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        showIpForm.append(deviceIp);
        display.setCurrent(showIpForm);

        try {
            System.out.println("Waiting for client request...");
            // Wait for a connection.
            // A socket is accessed using a generic connection string with an explicit host and port number.
            // acceptAndOpen() inherited from interface javax.microedition.io.StreamConnectionNotifier
            // Returns a StreamConnection object that represents a server side socket connection.
            // The method blocks until a connection is made.
            socCon = (SocketConnection) serSocCon.acceptAndOpen();
            System.out.println("Accepted and open the connection...");
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        try {
            // InputStream is an abstract class and it is the superclass of all classes representing an input stream of bytes.
            // openDataInputStream() inherited from interface javax.microedition.io.InputConnection
            // openDataInputStream() Open and return an input stream for a connection.
            is = socCon.openDataInputStream();
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        try {
            // OutputStream is an abstract class and it is the superclass of all classes representing an output stream of bytes.
            // An output stream accepts output bytes and sends them to some sink.
            // openDataOutputStream() inherited from interface javax.microedition.io.OutputConnection
            // openDataOutputStream() open and return a data output stream for a connection.
            os = socCon.openDataOutputStream();
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        // Send our chat to other party
        // Initialization part have to doen begining caz Send command want to use the send() in MessageSender class
        // We pass the TextField as argement caz we want to clear the field before sent another chat
        msgSenderClass = new MessageSender(os, chatTxtFld);
        msgSenderClass.start();

        //clear();

        // Receive other party's chat and load our chatting interface
        MessageReceiver msgReceiverClass = new MessageReceiver(is, srvChattingFrm);
        msgReceiverClass.start();

        infoAlert = new Alert("Client connected successfully.");
        display.setCurrent(infoAlert, srvChattingFrm);
    }

    public void clear(){
        chatTxtFld.setString("");
        //msgSenderClass.start();
    }

    public TextField getChatTxtFld() {
        return chatTxtFld;
    }   
}

Just as I told you in my earlier posts, do not give-up by looking at the length of the code. Most of the lines contain comments explaining the technical aspect of using that class, methods, variables etc…

I have uploaded all the files in to GitHub including this. So you can follow this link and download the source code. Do not forget to read “ReadMe-Before-Download” file 😉

Have a nice day.