//// 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 com.nokia.mid.messaging.*;class NokiaSmsHandler    extends SmsHandler    implements MessageListener{    private final static String PROTOCOL = "com.nokia.sms://";    private MessageConnection conn;    NokiaSmsHandler()    {    }    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(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() + "'");        }    }    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.registerMessageListener(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 NokHandler object is created.        if (conn != null)        {            try            {                conn.registerMessageListener(null);                conn.close();            }            catch (Exception e)            {                // Since we are aborting, no error handling needed.            }            conn = null;        }        super.abort();    }}