wmasmshandler.java

J2ME MIDP_Example_Applications

//
// Copyright 2002 Nokia Corporation.
//
// THIS SOURCE CODE IS PROVIDED 'AS IS', WITH NO WARRANTIES WHATSOEVER,
// EXPRESS OR IMPLIED, INCLUDING ANY WARRANTY OF MERCHANTABILITY, FITNESS
// FOR ANY PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE
// OR TRADE PRACTICE, RELATING TO THE SOURCE CODE OR ANY WARRANTY OTHERWISE
// ARISING OUT OF ANY PROPOSAL, SPECIFICATION, OR SAMPLE AND WITH NO
// OBLIGATION OF NOKIA TO PROVIDE THE LICENSEE WITH ANY MAINTENANCE OR
// SUPPORT. FURTHERMORE, NOKIA MAKES NO WARRANTY THAT EXERCISE OF THE
// RIGHTS GRANTED HEREUNDER DOES NOT INFRINGE OR MAY NOT CAUSE INFRINGEMENT
// OF ANY PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OWNED OR CONTROLLED
// BY THIRD PARTIES
//
// Furthermore, information provided in this source code is preliminary,
// and may be changed substantially prior to final release. Nokia Corporation
// retains the right to make changes to this source code at any time,
// without notice. This source code is provided for informational
// purposes only.
//
// Nokia and Nokia Connecting People are registered trademarks of Nokia
// Corporation. Java and all Java-based marks are trademarks or registered
// trademarks of Sun Microsystems, Inc. Other product and company names
// mentioned herein may be trademarks or trade names of their respective owners.
//
// A non-exclusive, non-transferable, worldwide, limited license is hereby
// granted to the Licensee to download, print, reproduce and modify the
// source code. The licensee has the right to market, sell, distribute and
// make available the source code in original or modified form only when
// incorporated into the programs developed by the Licensee. No other
// license, express or implied, by estoppel or otherwise, to any other
// intellectual property rights is granted herein.
//


import java.io.*;
import javax.microedition.io.*;
import javax.wireless.messaging.*;


public class WmaSmsHandler
    extends SmsHandler
    implements MessageListener
{
    private final static String PROTOCOL = "sms://";

    private MessageConnection conn;


    WmaSmsHandler()
    {
    }


    protected void doSend(OutgoingTextMessage outgoing)
    {
        try
        {
            TextMessage message =
                (TextMessage) conn.newMessage(MessageConnection.TEXT_MESSAGE);

            String outgoingAddress = outgoing.getAddress();

            if (outgoingAddress.indexOf(':') == -1)
            {
                outgoingAddress += ":" + port;
            }

            message.setAddress(PROTOCOL + outgoingAddress);
            message.setPayloadText(outgoing.getMessage());
            conn.send(message);

            outgoingListener.handleOutgoingOk(outgoing);
        }
        catch (SecurityException e)
        {
            outgoingListener.handleOutgoingCancel(outgoing, "Security");
        }
        catch (InterruptedIOException e)
        {
            outgoingListener.handleOutgoingCancel(outgoing, "Interrupted");
        }
        catch (Exception e)
        {
            outgoingListener.handleOutgoingError(outgoing,
                "Outgoing Error:" + e);
        }
    }


    protected void doReceive()
    {
        try
        {
            Message message = conn.receive();

            if (message instanceof TextMessage)
            {
                TextMessage textMessage = (TextMessage) message;
                String payload = textMessage.getPayloadText();
                String address = textMessage.getAddress();

                String phoneNumber = address; // default
                // strip off PROTOCOL prefix if any
                int beginIndex = 0;
                if (address.startsWith(PROTOCOL))
                {
                    beginIndex = PROTOCOL.length();
                }
                // strip off portnumber ending if any
                int endIndex = address.lastIndexOf(':');
                if (endIndex > beginIndex)
                {
                    phoneNumber = address.substring(beginIndex, endIndex);
                }
                else
                {
                    phoneNumber = address.substring(beginIndex);
                }

                incomingListener.handleIncomingMessage(phoneNumber, payload);
            }
            else
            {
                incomingListener.handleIncomingError(
                    "Incoming Error: Non-text message received");
            }
        }
        catch (Exception e)
        {
            incomingListener.handleIncomingError(
                "Incoming Error: '" + e.getMessage() + "'");
        }
    }


    // this method is from MessageListener
    public synchronized void notifyIncomingMessage(MessageConnection conn)
    {
        incomingMessagesPending++;

        synchronized (this)
        {
            notify(); // wake up the SmsHandler thread
        }
    }


    protected boolean openServerModeConnection()
    {
        try
        {
            conn = (MessageConnection) Connector.open(PROTOCOL + ":" + port);
            conn.setMessageListener(this);
        }
        catch (Exception e)
        {
            conn = null;
        }
        return (conn != null);
    }


    void abort()
    {
        // Cleanup the server connection. Note that 'conn' is created in the
        // constructor and destroyed here, so sending/receiving are no longer
        // possible after an abort, unless a new WmaHandler object is created.

        if (conn != null)
        {
            try
            {
                conn.setMessageListener(null);
                conn.close();
            }
            catch (Exception e)
            {
                // Since we are aborting, no error handling needed.
            }
            conn = null;
        }

        super.abort();
    }
}