Categories: Java ME | MIDP 2.0 | Code Examples | WMA 2.0 (JSR-205) | S60 3rd Edition, Feature Pack 1

This page was last modified 06:23, 27 May 2008.

From Forum Nokia Wiki

Knowledge Base Home

Overview

This code snippet demonstrates how to send a binary SMS. Binary messages are used, for example, to deliver application-specific settings to the user. In practice, in order for binary messages to be usable, their format must be defined - otherwise the device will not understand them.

In the snippet, the user enters a phone number to a text field. He or she may also fetch the number from the address book. Then, by selecting Options > Send, the SMS is sent to that number.

This is a complete example MIDlet, but the most interesting methods (methods regarding SMS handling) are handleSendCommand(), prepareSMS(), and sendSMS().

Source file

import java.io.IOException;
import java.io.InterruptedIOException;
import javax.microedition.io.Connector;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.TextField;
import javax.microedition.midlet.MIDlet;
import javax.wireless.messaging.BinaryMessage;
import javax.wireless.messaging.MessageConnection;

public class SMSMIDlet extends MIDlet implements CommandListener {
    private Command sendCommand;
    private Command exitCommand;
    private Form mainForm;
    private TextField smsAddress;
    private MessageConnection connection;
    
    /**
     * Constructor. Constructs the object and initializes displayables.
     */
    public SMSMIDlet() {
        mainForm = new Form("SMS Example");
        
        smsAddress = new TextField("Phone number", null, 20,
            TextField.PHONENUMBER);
        mainForm.append(smsAddress);
        
        sendCommand = new Command("Send", Command.ITEM, 0);
        mainForm.addCommand(sendCommand);
 
        exitCommand = new Command("Exit", Command.EXIT, 0);
        mainForm.addCommand(exitCommand);
        
        mainForm.setCommandListener(this);
    }
    
    /**
     * From MIDlet.
     * Called when the MIDlet is started.
     */
    public void startApp() {
        // The initial display is the main form
        Display.getDisplay(this).setCurrent(mainForm);
    }
 
    /**
     * From MIDlet.
     * Called to signal the MIDlet to enter the Paused state.
     */
    public void pauseApp() {
        // No implementation required
    }
 
    /**
     * From MIDlet.
     * Called to signal the MIDlet to terminate.
     * @param unconditional whether the MIDlet has to be unconditionally
     * terminated
     */
    public void destroyApp(boolean unconditional) {
        if (connection != null) {
            try {
                // Close the message connection
                connection.close();
            } catch (IOException ex) {
                // TODO: Exception handling
            }
        }
    }
 
    /**
     * From CommandListener.
     * Called by the system to indicate that a command has been invoked on a
     * particular displayable.
     * @param command the command that was invoked
     * @param displayable the displayable where the command was invoked
     */
    public void commandAction(Command command, Displayable displayable) {
        if (command == exitCommand) {
            // Exit the MIDlet
            destroyApp(true);
            notifyDestroyed();
        } else if (command == sendCommand) {
            handleSendCommand();
        }
    }
 
    private void handleSendCommand() {
        try {
            // Open the connection
            connection = (MessageConnection)Connector.open("sms://:5000");
        } catch (IOException ex) {
            // TODO: Exception handling
        }
            
        BinaryMessage message = prepareSMS();
        sendSMS(message);
    }
 
    /**
     * Sets the address and payload data for the binary SMS.
     */
    private BinaryMessage prepareSMS() {
        // Prepare the binary message
        BinaryMessage message = (BinaryMessage)connection.newMessage(
            MessageConnection.BINARY_MESSAGE);
        
        // Set the destination address
        String address = "sms://" + smsAddress.getString();
        message.setAddress(address);
        
        // Set the data
        byte[] data = obtainByteData();
        message.setPayloadData(data);
        
        return message;
    }
 
    /**
     * Constructs a byte array and fills it with data that is to be sent as an
     * SMS message.
     */
    private byte[] obtainByteData() {
        // Implementation not provided
        // ...
    }
 
    /**
     * Sends a binary SMS.
     */
    private void sendSMS(final BinaryMessage message) {
        // Send the message on its own thread of execution
        Thread smsThread = new Thread() {
            public void run() {
                try {
                    connection.send(message);
                    mainForm.append("Message sent.");
                } catch (InterruptedIOException ex) {
                    // TODO: Exception (e.g. timeout) handling
                } catch (IOException ex) {
                    // TODO: Exception (e.g. network failure) handling
                } catch (IllegalArgumentException ex) {
                    // TODO: Exception (e.g. too big or otherwise invalid
                    // message) handling
                } catch (SecurityException ex) {
                    // TODO: Exception (e.g. insufficient permissions) handling
                }
            }
        };
        smsThread.start();
    }
}

Postconditions

The MIDlet sends a binary SMS to the number specified by the user.

See also

• CS000976 - Sending a text SMS
• CS000978 - Sending a multipart MMS