Sending A Wireless Text-Message With Java

Photo of author

By Miro Stoichev

After years of hype, the wireless market is finally upon us. Built upon competitive prices and a large growing user base around the globe, the wireless market is expected to grow at astronomical rates. The GSM Association anticipates monthly global SMS volumes to reach an amazing 25 billion mark by December 2001. ( Fortunately, for application developers, data and information services are experiencing the largest growth levels within the wireless market, thereby bringing new opportunities for revenue. However, even in the midst of “wireless” hype, many developers are still having difficulties navigating around the challenges of the esoteric SMS world. Obstacles such as fragmentation of carriers, inconsistent transport mechanisms and differing message lengths pose numerous complications. Developers who successfully surpass these obstacles are then faced with a new set of difficulties for building a solution in Java.

Challenges of Sending an SMS Message from Java

Although SMS (Short Message Service) has proven itself as a robust medium for mobile information, there are many hidden problems preventing developers from using the technology in their applications. SMS is merely a description of services, which wireless carriers provide, rather than a description for a method of delivery. There are many different wireless networks that deliver SMS such as PDC, CDMA, TDMA, GSM or iDEN. These networks communicate over numerous protocols such as SMPP (Short Message Peer-to-Peer), UCP (Universal Computer Protocol), HTTP (Hypertext Transfer Protocol), SMTP (Simple Mail Transport Protocol), etc. Unfortunately, this lack of standards for SMS has increased development learning curves and slowed down adoption rates.

Inconsistent transports are only a small part of the larger dilemma. Typically, carriers do not allow public access to their networks and some will not even allow private access. This exclusivity leaves developers with very few options. Many developers opt to simply bypass the carrier and implement their own somewhat functional solutions.

The problem is additionally magnified with the proliferation of various mobile devices, each built with differing technologies and capabilities. Some mobile phones support one-way text-messaging, while others support two-way text-messaging. Some devices are capable of receiving only 140 character messages, while others can receive 600 character messages. Other mobile phones can display images and download binary data, while others cannot. Because of these frustrating differences, the process of sending and receiving wireless messages with mobile devices requires the development and maintenance of extensive technological resources and information about each carrier and every device.

Aside from the process of sending and receiving text-messages, numerous extended services, which surround wireless devices, are also required in order to realize the full potential offered by today’s wireless technologies. Wireless device metadata is essential in developing and deploying many new applications such as instant messaging, advertisements, location-based services, etc.

Businesses and consumers are left with ad hoc solutions that fail to unleash the true power of today’s mobile devices. It often becomes cost prohibitive for businesses to integrate emerging wireless technologies into their existing infrastructure. If true communication to any wireless device, regardless of carrier, were possible, many past successes would seem miniscule in light of future opportunities.

Using SMTP to Send a Text-Message

Many wireless carriers now expose an SMTP (Simple Mail Transport Protocol) or an email interface to send SMS. In many cases, the email address will typically be the device’s phone number or pager identification number along with the carrier’s special domain. For example, a phone with Sprint PCS service will have an email address of SMTP is an attractive method of sending SMS. The use of SMTP is free for the sender and software development kits for implementing the protocol are easily accessible.

Unfortunately, most cost free solutions are littered with drawbacks, particularly in the use of SMTP. Disadvantages of SMTP include the lack of speed, assurance, error checking, features and consistency. By its original design, email was not developed to function as a quick system. As a result, most text-messages sent through email experience latency problems ranging from 1 minute to 2 hours. The speed of an email also relies on a dependable STMP server-one that does not crash somewhere along the path of an email. Email cannot guarantee that the recipient of the message has subscribed to text-messaging in their carrier’s normal service plan.

Typical SMS lengths range from 80 to 256 characters. Messages delivered via SMTP will normally eliminate portions of the message that go over the maximum character length. In many cases, the most important part of the message will be deleted unknowingly. The code will never discover the mishap. An additional conflict arises within the diversity of email formats used between services. In some instances, only the subject field or body field of a text-message will be used. SMTP code needs to account for these intricacies to assure that certain elements of the message will transmit to the mobile device. The From field showcases another imperfection when using SMTP. This field utilizes up to 20 to 30 characters within an already limited space of 80 to 256 characters.

Beyond the problems associated with speed and assurance, SMTP fails to expose many of the best features specifically available with SMS such as one-touch callback and presence information (e.g. phone on/off or signal strength).

Review the following sample Java code in order to learn how SMS might be delivered via SMTP. The following example uses Sun Microsystem’s JavaMail package to implement SMTP.

// Package Imports import*; import; import java.util.Properties; import java.util.Date; import javax.mail.*; import javax.mail.internet.*; import javax.activation.*; // Public Class public class EmailSMS { // Global Variables String TO; String FROM; String SUBJECT; String TEXT; String MAILHOST; String LASTERROR; // Main function executed public static void main(String[] args) throws Exception { EmailSMS SMS = new EmailSMS(); SMS.setMailHost(“”); SMS.setTo(“”); SMS.setFrom(“”); SMS.setSubject(“”); SMS.setText(“Hello World!”); boolean ret = SMS.send(); if (ret) { System.out.println(“SMS was sent!”); } else { System.out.println(“SMS was not sent – ” + SMS.getLastError()); } } // Public Constructor public EmailSMS() { TO = null; FROM = null; SUBJECT = null; TEXT = null; MAILHOST = null; LASTERROR = “No method called.”; } public void setTo(String to) { TO = to; } public String getTo() { return TO; } public void setFrom(String from) { FROM = from; } public String getFrom() { return FROM; } public void setSubject(String subject) { SUBJECT = subject; } public String getSubject() { return SUBJECT; } public void setText(String text) { TEXT = text; } public String getText() { return TEXT; } public void setMailHost(String host) { MAILHOST = host; } public String getMailHost() { return MAILHOST; } public String getLastError() { return LASTERROR; } // Will attempt to send the Email SMS and return a boolean meaning it // either failed or succeeded. public boolean send() { // Variables to check message length. int maxLength; int msgLength; // Check to make sure that the parameters are correct if (TO.indexOf(“”) > 0) { maxLength = 140; } else if (TO.indexOf(“”) > 0) { maxLength = 280; } else if (TO.indexOf(“”) > 0) { maxLength = 100; } else { maxLength = 160; } // Calculate message length msgLength = FROM.length() + 1 + SUBJECT.length() + 1 + TEXT.length(); // Typically, there are at least two characters of delimiter // between the from, subject, and text. This is here to make // sure the message isn’t longer than the device supports. if (msgLength > maxLength) { LASTERROR = “SMS length too long.”; return false; } // Set Email Properties Properties props = System.getProperties(); if (MAILHOST != null) { props.put(“”, MAILHOST); } // Get a Session object Session session = Session.getDefaultInstance(props, null); try { // Construct the email Message msg = new MimeMessage(session); // Set From if (FROM != null) { msg.setFrom(new InternetAddress(FROM)); } else { msg.setFrom(); } // Set Subject msg.setSubject(SUBJECT); // Set Text msg.setText(TEXT); // Add Recipient msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse(TO, false)); // Sent Date msg.setSentDate(new Date()); // Send Email SMS Transport.send(msg); LASTERROR = “Success.”; return true; } catch (MessagingException mex) { LASTERROR = mex.getMessage(); return false; } } }

Using a Third-Party Wireless Platform to Send a Text-Message

If SMTP falls short of easing your wireless pain, then the use of a third-party platform will solve your problem, while hiding the intricacies involved with SMS. Third party solutions often range from shrink-wrapped software to application service provider gateways. One such third-party platform is provided by Simplewire, Inc. Simplewire acts as an operating system between the Internet and any wireless device. Using Simplewire’s Java Software Development Kit allows for the easy integration of powerful text-messaging services. Natively implementing text- messaging services into individual applications forgoes the need to worry about wireless technologies or varying protocols.

The advantages associated with the use of a third-party platform outweigh several of the short-term yet half-baked benefits of SMTP. Third-party platforms such as Simplewire’s not only can consistently cover every major carrier, but also confirm message delivery while having faster performance than SMTP. The relatively simple solution of using a third-party platform solves a complex wireless problem for numerous developers. The following example demonstrates how to send a text- message using Simplewire’s Java Software Development Kit:

// Imports import com.simplewire.sms.*; // Public Class public class SimplewireSMS extends java.lang.Object { public static void main(String[] args) throws Exception { // Create SMS Object SMS sms = new SMS(); // Set Message Properties sms.setMsgPin(“1005101234”); sms.setMsgFrom(“Joe”); sms.setMsgCallback(“6165551212”); sms.setMsgText(“Hello World From Java SMS!”); // Display The Status System.out.println(“Submitting SMS To Simplewire…”); // Send the request to simplewire sms.msgSend(); // Check if the request was sent if (sms.isSuccess()) { // Display the status System.out.println( “The message was sent!” ); } // Display the error info else { // Check If Carrier Recognition Error if(sms.getErrorCode().equals(“345”)) { System.out.println(“Sample request was success.”); System.out.println(“However, could not recognize carrier.\n”); } else { // Display Error Info System.out.println(“The message was not sent!”); System.out.println(“Error Code: ” + sms.getErrorCode()); System.out.println(“Error Description: ” + sms.getErrorDesc() + “\n”); } } } }


The use of third-party solutions and/or shrink-wrapped Java Software Development Kits provides a very simple and efficient mode for sending and receiving SMS. Keep in mind that most solutions will have licensing and usage fees since carriers set their own final pricing. Implementing SMTP will certainly provide a low-priority path to a limited amount of wireless devices, but the amount of email-supporting devices is extremely small on a global scale. The use of SMTP also generates many serious yet hidden conflicts with the delivery of text-messages. If performance, reliability and scalability are important concerns while integrating text-messaging into your own applications, seeking a third-party component may be your best solution!

About The Author

Joe Lauer is the founder and president of Simplewire Inc., which provides a wireless text-messaging platform to businesses and consumers. Lauer founded Simplewire to solve the problem of getting wireless text-messages off of the Internet and onto mobile devices. Joe Lauer studied Computer Science and Business at the University of Michigan, Ann Arbor. Mr. Lauer is currently authoring a book on SMS and has written numerous articles on the subject. He can be reached at

About Simplewire

Simplewire is a wireless text-messaging platform capable of messaging across all wireless networks regardless of carrier. Our products and services simplify and enhance the way businesses and consumers communicate through all SMS (Short Message Service) phones, RIM devices, two-way and one-way pagers.

Beyond SMS, our technology delivers numerous extended services such as carrier recognition, device features, delivery confirmation, and device presence (phone on/off).

Simplewire acts as an operating system between the Internet and any wireless device. With Simplewire, you can easily integrate powerful text-messaging services natively into your own applications or infrastructure via our Software Development Kits or open Application Programming Interface.

Erin Ribiat
Chief Evangelist
743 Beaubien, Suite 300
Detroit, MI 48226
p. 313.879.1000
f. 313.961.4568

Does your company have a new or innovative solution that WDN should know about? Send details to

Leave a Comment