URL: http://www.etsi.org/

SMS was created by the European Telecommunications Standards Institute (ETSI).

SMS messages are pure text. On GSM networks, a standard text message can be a maximum of 160 characters long. Each character is usually defined by a 7-bit alphabet similar to ASCII that includes major punctuation, accented letters, mathematic symbols, and numerals. Some other networks permit a maximum of 190 characters.

There are two formats in which you can send and receive SMS messages:

Additionally, there are specialized versions of SMS that enable instant pop-up messages, as well as the capability to tack on multimedia and contact information. Some of these formats will be discussed later in this chapter.

All SMS messages are routed through a central server, known as a Short Message Service Center (SMSC). The SMSC is software that basically acts as a post office. It sits atop the operator's network and queues up messages, bills the sender, routes messages to phones, notifies the sender if the message can't be sent, and even sends return receipts when the messages are read.

The reason an SMSC is needed is that mobile phones are not always on. Users often switch their phones off, are out of the network coverage area, or run out of battery power. The SMSC stores each message and queues it up, trying to send it out as soon as possible. If the phone is unavailable, the SMSC will periodically keep trying. After the message is successfully sent, the SMSC deletes the message from its cache and continues on with other work.

Most operators permit you to tap into their SMSC using the Web or other open Internet connections. Every provider uses different protocols for their SMSC. For example, CMG uses a protocol called UCP/EMI, Logica uses SMPP, SEMA uses SMS2000, and Nokia uses CIMD.

Figure 5.1 shows the typical SMS architecture: Either a phone or Web server gateway machine can connect to a SMSC to send or receive SMS messages.

Figure 5.1. The SMS architecture.

The following are several SMS services you can use to send SMS messages from the Web:

There are also several services that enable you to use SMS to reach various Internet gateways. Many service providers have created their own portal, enabling you to send and synchronize your e-mail, schedule, or other contact information using SMS. For example

Some carriers also allow you to use SMS to access the wider Internet. For example, one free server can be found at http://www.excell.to/. After you have registered, you can get the phone number of the gateway (which is in Italy) and actually send out an e-mail using SMS and the following format:

EMAIL user@domain .subject.message body

There are numerous SMS tools on the market, most of them geared toward carriers, large corporations, and other organizations that want to add SMS capabilities to their communications arsenal.

The following are some examples:

Actually sending an SMS message, then, might work according to the following process.

You will need to have all the following pieces in place:

The access will usually be through a servlet with a command structure similar to

http://www.myprovider.com/sendsms?msg=Message&destination= 555-765-4321&callback
_number=555-123-4567 &priority=normal& date=4/15&time=10:30

To send a message to a specific provider, your Java code will look similar to the following:

String smsMsg = new String();
smsMsg = "msg=" + URLEncoder.encode(pMessage);
smsMsg = smsMsg + "&destination=" + URLEncoder.encode(pNumber);
smsMsg = smsMsg + "&callback_number=123456789";
smsMsg = smsMsg + "&priority=normal";

int date,month,hour,minute;
Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("EST"));
date = cal.get(cal.DAY_OF_MONTH);
month = cal.get(cal.MONTH) + 1;
hour = cal.get(cal.HOUR);
minute = cal.get(cal.MINUTE) + 1;

smsMsg = smsMsg + "&date=" + URLEncoder.encode(month + "/" + date) ;
smsMsg = smsMsg + "&time=" + URLEncoder.encode(hour + ":" + minute) ;

URL cellUrl = new URL("http://www.myprovider.com/sendsms");
HttpURLConnection conn = (HttpURLConnection) cellUrl.openConnection();
conn.setRequestMethod("POST");
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setUseCaches(false);
conn.setRequestProperty ("Content-Type", "application/x-www-form-urlencoded");

DataOutputStream ds = new DataOutputStream (conn.getOutputStream ());
ds.writeBytes (smsMsg);
ds.flush ();
ds.close ();

Note that you use the URLEncoder.encode() method to convert any strings into valid escape characters able to be sent over HTTP.

Just as SMS has its SMSCs, MMS has MMSCs that act as a central post office to send and receive each message. An entire MMS is sent in the background, using WAP's Wireless Service Protocol (WSP) to “push” content down to the phone. As such, WAP 1.2 or better is needed to support MMS.

MMS messages might take a while to reach the phone. For example, if a message is 50 kilobytes long (400 kilobits), and is sent over a network that supports 10Kbps bandwidth, it will take 40 seconds to send the message down. However, MMS phones will not notify users of a new message until it has been entirely downloaded and is ready to play. This makes messages “seem” instant.

MMSC also features distribution lists, enabling a sender to compose one message for many recipients.

URL: http://www.w3.org/TR/REC-smil/

The Synchronized Multimedia Integration Language is, as its name implies, a language that enables you to synchronize the playback of multimedia content. The language can juggle music, voice, images, text, and even video. It shows exactly where visual elements are laid out on the screen, when to play audio elements, and how long everything is displayed before switching to a new “slide.”

The language is based on XML, which is very similar to HTML, and was developed by major television, audio, new media, and video companies. The World Wide Web Consortium (W3C) standardized the final specification.

The content in SMIL messages is encapsulated using standard MIME types, with various phones capable of displaying and dealing with different formats of multimedia. Almost every MMS-capable phone will support these formats:

Additionally, different carriers will permit different message lengths. Nokia, for example, is planning on permitting messages from 30 to 100 kilobytes in size.

Using MMC and SMIL, then, you could create a game that shows a tiny image of your evil nemesis taunting you in a left-hand pane while text statistics about your army scroll by on the right. Meanwhile, scary music could play.

A SMIL file to achieve this might look something like this:

<smil >
 <head >
 <layout >
  <root-layout width="580" height="213" background-color="black"/>
  <!— Text region —>
  <region id="text" left="0" top="0" width="50" height="100"/>
  <!— Image region —>
  <region id="images" left="101" top="0" width="50" height="100"/>
 </layout>
 </head >
 <body>
 <par>
  <text src="message.txt" region="text_region" begin="1s" />
  <img src="badguy.gif" region="images_region" begin="1s" />
  <audio src="scary.au" clip-end="145s" />
  </par>
 </body>
</smil>

The preceding file only shows one sequence. You could easily use SMIL to set a duration for the sequence and then swap out graphical elements, add new text, and so on.

URL: http://www.3gpp.org/

Because networks and phones that can support MMS will take a while to hit the market, Alcatel, Ericsson, Motorola, and Siemens have developed an interim messaging standard called the Enhanced Messaging Service (EMS). The standard is defined by the Third Generation Partnership Project (3GPP).

EMS adds images, audio, melodies, and animations to SMS. Unlike MMS, which turns messages into a full-fledged slide show, EMS works more like a still picture. For instance, if you receive an EMS message, a special icon will indicate that an image, some music, or even a brief animation is attached. The EMS message can even combine types, so that a black and white graphic appears next to the message while a small clip of music plays in the background.

Features that EMS supports include the following:

EMS-capable phones will begin shipping at the end of 2001 and are expected to be popular and widely used near the end of 2002.