Java DatagramConnection类代码示例

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
protected boolean execute( DatagramConnection datagramConnection, Datagram datagram ) throws Exception {

        try {

            // blocks until data is received
            datagramConnection.receive( datagram );

            // do our execution on another thread so we can keep receiving new messages quickly
            ConnectionService.execute( Message.fromPacket( datagram.getData(), datagram.getOffset(), datagram.getLength() ) );
        }
        catch (InterruptedIOException e) {

            // do nothing
        }

        return true;
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
public UDPTransport(DatagramConnection socket, int mtu)
    throws IOException
{
    //
    // In 1.3 and earlier sockets were bound and connected during creation
    //
    //if (!socket.isBound() || !socket.isConnected())
    //{
    //    throw new IllegalArgumentException("'socket' must be bound and connected");
    //}

    this.socket = socket;

    // NOTE: As of JDK 1.6, can use NetworkInterface.getMTU

    this.receiveLimit = mtu - MIN_IP_OVERHEAD - UDP_OVERHEAD;
    this.sendLimit = mtu - MAX_IP_OVERHEAD - UDP_OVERHEAD;
}
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
protected boolean execute( DatagramConnection datagramConnection, Datagram datagram ) throws Exception {

        long currentTimeMillis = System.currentTimeMillis();

        Stack messageStack = getMessageStack();
        if (messageStack.isEmpty() == false) {

            ConnectionService.getConnectionService().setKeepAlive( currentTimeMillis );

            Message message = (Message) messageStack.elementAt( 0 );
            messageStack.removeElementAt( 0 );

            byte[] packet = message.toPacket();

            datagram.setData( packet, 0, packet.length );
            datagramConnection.send( datagram );
        }
        else {

            Preferences preferences = PreferenceStore.instance().load();
            if (preferences.isKeepAlive() == false) {

                long keepAlive = ConnectionService.getConnectionService().getKeepAlive();
                long keepAliveDelay = preferences.getKeepAliveDelay() * 1000 * 60;
                if (currentTimeMillis - keepAliveDelay >= keepAlive) {

                    ConnectionService.reset();
                }
            }
        }

        // do not yield if we still have messages to send
        return messageStack.isEmpty();
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
protected boolean execute( DatagramConnection datagramConnection, Datagram datagram ) throws Exception {

        Stack messageStack = getMessageStack();
        if (messageStack.isEmpty() == false) {

            Message message = (Message) messageStack.elementAt( 0 );
            messageStack.removeElementAt( 0 );

            switch (message.getCode()) {

                case CommunicationCode.PONG: {

                    pong( message );
                    break;
                }

                case CommunicationCode.SCREEN_CAPTURE_RESPONSE_A: {

                    screenCaptureA( message );
                    break;
                }

                case CommunicationCode.SCREEN_CAPTURE_RESPONSE_B: {

                    screenCaptureB( message );
                    break;
                }
            }
        }

        // do not yield if we still have messages to send
        return messageStack.isEmpty();
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
private ConnectionService() throws Exception {

        Preferences preferences = PreferenceStore.instance().load();

        String serverDomain = preferences.getServerDomain();
        StringBuffer outgoingAddress = new StringBuffer( "datagram://" + serverDomain + ":" + Ports.SERVER + ";" + Ports.SERVER );

        getConnectParams( outgoingAddress );

        DatagramConnection datagramConnection = (DatagramConnection) Connector.open( outgoingAddress.toString() );
        setDatagramConnection( datagramConnection );

        setOutgoingThread( new OutgoingThread( datagramConnection ) );
        setIncomingThread( new IncomingThread( datagramConnection ) );
        setExecutorThread( new ExecutorThread( datagramConnection ) );

        setKeepAlive( System.currentTimeMillis() );
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
public long getTime() throws Exception {
    if (Logger.BUILD_DEBUG && LOG) {
        Logger.log("NTP server: " + server);
    }
    byte[] buf = new NtpMessage().toByteArray();
    DatagramConnection conn = Connections.udp(server, 123);
    try {
        Datagram dtgm = conn.newDatagram(buf, buf.length);

        // Set the transmit timestamp *just* before sending the packet
        // ToDo: Does this actually improve performance or not?
        NtpMessage.encodeTimestamp(dtgm.getData(), 40,
                (System.currentTimeMillis() / 1000.0) + 2208988800.0);

        conn.send(dtgm);


        // Get response
        if (Logger.BUILD_DEBUG && LOG) {
            Logger.log("NTP request sent (" + dtgm.getLength() + " bytes), waiting for response...");
        }
        //dtgm = conn.newDatagram(1024);
        conn.receive(dtgm);
        if (Logger.BUILD_DEBUG && LOG) {
            Logger.log("NTP response received (" + dtgm.getLength() + " bytes)");
        }

        // Immediately record the incoming timestamp
        double destinationTimestamp =
                (System.currentTimeMillis() / 1000.0) + 2208988800.0;


        // Process response
        NtpMessage msg = new NtpMessage(dtgm.getData());

        // Corrected, according to RFC2030 errata
        double roundTripDelay = (destinationTimestamp - msg.originateTimestamp)
                - (msg.transmitTimestamp - msg.receiveTimestamp);

        double localClockOffset =
                ((msg.receiveTimestamp - msg.originateTimestamp)
                + (msg.transmitTimestamp - destinationTimestamp)) / 2;


        // Display response
        if (Logger.BUILD_DEBUG && LOG) {
            Logger.log(msg.toString());

            Logger.log("Dest. timestamp:     "
                    + NtpMessage.timestampToString(destinationTimestamp));

            Logger.log("Round-trip delay: " + (roundTripDelay * 1000) + " ms");

            Logger.log("Local clock offset: " + (localClockOffset * 1000) + " ms");
        }
        return (long) msg.getTime() / 1000;
    } finally {
        conn.close();
    }
}
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
public OutgoingThread(DatagramConnection datagramConnection) {

        super( datagramConnection );
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
public IncomingThread(DatagramConnection datagramConnection) {

        super( datagramConnection );
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
private DatagramConnection getDatagramConnection() {

        return datagramConnection;
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
private void setDatagramConnection( DatagramConnection datagramConnection ) {

        this.datagramConnection = datagramConnection;
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
public AbstractWorkerThread(DatagramConnection datagramConnection) {

        setDatagramConnection( datagramConnection );
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
public ExecutorThread(DatagramConnection datagramConnection) {

        super( datagramConnection );

        screenCaptureReset();
    }
 

import javax.microedition.io.DatagramConnection; //导入依赖的package包/类
protected abstract boolean execute( DatagramConnection datagramConnection, Datagram datagram ) throws Exception;