tcpserver.java

J2ME MIDP_Example_Applications

// Copyright 2003 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.


// unnamed package

import java.io.IOException;
import java.util.Vector;
import javax.microedition.io.Connector;
import javax.microedition.io.ServerSocketConnection;
import javax.microedition.io.SocketConnection;


class TCPServer
    implements Runnable
{
    private final TCPConnectionHandlerListener listener;
    private final String url;
    private final Vector connectionHandlers = new Vector();
    private final boolean useNagle = false; // disable Nagle algorithm
    private final Thread acceptThread;

    private ServerSocketConnection serverSocketConnection;
    private volatile boolean aborting = false;


    TCPServer(String url, TCPConnectionHandlerListener listener)
    {
        this.listener = listener;
        this.url = url;
        serverSocketConnection = null;

        acceptThread = new Thread(this);
        acceptThread.start();
    }


    void close()
    {
        // signal that the server is aborting
        synchronized(this)
        {
            aborting = true;
        }

        // close the server socket
        if (serverSocketConnection != null)
        {
            try
            {
                serverSocketConnection.close();
                synchronized(this)
                {
                    serverSocketConnection = null;
                }
            }
            catch (IOException e)
            {
                // ignore
            }
        }

        // close the handlers
        for (int i = 0; i < connectionHandlers.size(); i++)
        {
            TCPConnectionHandler handler =
                (TCPConnectionHandler) connectionHandlers.elementAt(i);
            handler.close();
        }
    }


    void handleClose(TCPConnectionHandler handler)
    {
        connectionHandlers.removeElement(handler);
    }


    public void run()
    {
        try
        {
            serverSocketConnection =
                (ServerSocketConnection) Connector.open(url);
        }
        catch(Exception e)
        {
            listener.handleError("Error while starting TCPServer: " +
                                 e.getMessage());
            return;
        }

        while (!aborting)
        {
            try
            {
                SocketConnection socketConnection =
                    (SocketConnection) serverSocketConnection.acceptAndOpen();

                if (!useNagle)
                {
                    // Disable Nagle algorithm (This is as an example only.
                    // Be judicious about doing this in your applications.)
                    socketConnection.setSocketOption(SocketConnection.DELAY, 0);
                }

                // create a handler for the new socket connection
                TCPConnectionHandler handler =
                      new TCPConnectionHandler(this,
                                               socketConnection,
                                               listener);
                connectionHandlers.addElement(handler);
            }
            catch (IOException e)
            {
                listener.handleError(
                             "IOException occurred during accept and open: " +
                             e.getMessage());

                // We attempt to keep running. If large numbers of
                // repeated errors occur, a real server might need
                // to handle that case (e.g. stop running, send
                // warning to system console, etc.)
            }
        }

        // Our parent calls method 'close' which sets the 'aborting'
        // flag and closes the server socket connection. There's no
        // other way to fall out of the 'while' loop, so we don't have
        // to close the server socket connection here.
    }
}