import javax.microedition.io.SocketConnection; //导入依赖的package包/类
private boolean openConnection(int index, boolean outputError) {
	System.out.println("Attempting to connect to " + remoteIPList[index]);
	if (index < 0 || index >= lastConnectionAttempt.length)
		return false;
	lastConnectionAttempt[index] = System.currentTimeMillis();
	try {
		// This is my version of a "timeout" for 5000ms
		//Timer t = new Timer();
		//t.schedule(new TimeoutTask(Thread.currentThread()), 5000);
		// This is what is being timed out
		comm = (SocketConnection)Connector.open("socket://"+remoteIPList[index]+":"+remotePort, connectionType, true);
		outputStream = comm.openOutputStream();
		return true;
	} catch (Exception ex) {
		outputStream = null;
		comm = null;
		if (outputError) {
			String error = toString()
					+ ": Failed to establish connection"
					+ " with driver station"
					+ " at " + remoteIPList[index]+":"+remotePort;
			System.out.println(error);
		}
		return false;
	}
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
void benchmarkLargeRead() throws IOException {
  SocketConnection client = (SocketConnection)Connector.open("socket://localhost:8000");

  OutputStream os = client.openOutputStream();
  os.write("GET /bench/benchmark.jar HTTP/1.1\r\nHost: localhost\r\n\r\n".getBytes());
  os.close();

  InputStream is = client.openInputStream();
  byte[] data = new byte[1024];
  int len;
  MemorySampler.sampleMemory("Memory before");
  long start = JVM.monotonicTimeMillis();
  do {
    len = is.read(data);
  } while (len != -1);
  System.out.println("large read time: " + (JVM.monotonicTimeMillis() - start));
  MemorySampler.sampleMemory("Memory  after");
  is.close();

  client.close();
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
void benchmarkLargeRead() throws IOException {
  SocketConnection client = (SocketConnection)Connector.open("socket://localhost:8000");

  OutputStream os = client.openOutputStream();
  os.write(("GET /bench/benchmark.jar HTTP/1.1\r\n" +
            "Host: localhost\r\n" +
            "Connection: close\r\n" +
            "\r\n").getBytes());
  os.close();

  InputStream is = client.openInputStream();
  byte[] data = new byte[1024];
  int len;
  long start = JVM.monotonicTimeMillis();
  do {
    len = is.read(data);
  } while (len != -1);
  System.out.println("large read time: " + (JVM.monotonicTimeMillis() - start));
  is.close();

  client.close();
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
public void run() {
    try {
        final ServerSocketConnection s = (ServerSocketConnection) Connector.open("serversocket://:" + port);
        while (listening) {
            final SocketConnection connection = (SocketConnection) s.acceptAndOpen(); // blocks until a connection is made
            final Thread t = new Thread(new VisionServerConnectionHandler(connection));
            t.start();
            connections.addElement(connection);
            try {
                Thread.sleep(100);
            } catch (final InterruptedException ex) {
                System.out.println("Thread sleep failed.");
            }
        }
    } catch (final IOException e) {
        System.out.println("Socket failure.");
        e.printStackTrace();
    }
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
private boolean testApn(String apn, String target) throws ATCommandFailedException {
    if (Logger.BUILD_DEBUG) {
        Logger.log(this + ".testApn( \"" + apn + "\", \"" + target + "\" );");
    }
    ATExecution.applyAPN(apn);

    try {
        SocketConnection conn = (SocketConnection) Connector.open("socket://" + target);
        conn.close();
        if (Logger.BUILD_DEBUG) {
            Logger.log("Connected ok !");
        }
        return true;
    } catch (Exception ex) {
        // This is the standard message for APN detection failure, let's skip it
        if (ex instanceof IOException && ex.getMessage().equals("Profile could not be activated")) {
            return false;
        }
        if (Logger.BUILD_CRITICAL) {
            Logger.log(this + ".testApn: " + ex);
        }
    }
    return false;
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
/**
 * Connect using custom settings
 * @param ip Address of Server "xxx.xxx.xxx.xxx"
 * @param port of Server "XXXXX"
 */
public void connect(String ip, String port, int bufferSize, char delimiter) throws IOException {
    this.ip = ip;
    this.port = port;
    this.bufferSize = bufferSize;
    this.delimiter = delimiter;
    beenConnected = true;
    url = "socket://" + ip + ":" + port; //Store URL of Connection
    System.out.println("Connecting to PI...");
    client = (SocketConnection) Connector.open(url, Connector.READ_WRITE, true); //Setup input and output through client SocketConnection
    try{            
        is = client.openInputStream();
        os = client.openOutputStream();
        if(true) {
            System.out.println("Connected to: "+client.getAddress() + ":" + client.getPort());
        }
        connected = true;
    }
    catch (Exception ex){
         connected = false;
    }
    
    
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
/**
 * Starts the module, by creating a TCP socket to the server.
 */
public void start() throws IOException, MqttException {
	final String methodName = "start";
	try {
		log.fine(className,methodName, "252", new Object[] {uri});
		connection = (SocketConnection) Connector.open(uri);
		connection.setSocketOption(SocketConnection.DELAY, 0);  // Do not use Nagle's algorithm
		in = connection.openInputStream();
		out = connection.openOutputStream();
	}
	catch (IOException ex) {
		//@TRACE 250=Failed to create TCP socket
		log.fine(className,methodName,"250",null,ex);
		throw new MqttException(MqttException.REASON_CODE_SERVER_CONNECT_ERROR, ex);
	}
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
/**
 * Starts the module, by creating a TCP socket to the server.
 */
public void start() throws IOException, MqttException {
	final String methodName = "start";
	try {
		log.fine(className,methodName, "252", new Object[] {uri});
		connection = (SecureConnection) Connector.open(uri);
		connection.setSocketOption(SocketConnection.DELAY, 0);  // Do not use Nagle's algorithm
		in = connection.openInputStream();
		out = connection.openOutputStream();
	}
	catch (IOException ex) {
		System.out.println(ex.getMessage());
		//@TRACE 250=Failed to create TCP socket
		log.fine(className,methodName,"250",null,ex);
		ex.printStackTrace();
		throw new MqttException(MqttException.REASON_CODE_SERVER_CONNECT_ERROR, ex);
	}
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
public Socket socketOpen(String url)
{
  try
  {
    Socket socket = new Socket();
    socket.socket = ((SocketConnection)Connector.open("socket://" + url));
    jcc2.lib.stdlib.library.getSingleton().setLastError(null);
    return socket;
  }
  catch (Exception e)
  {
    jcc2.lib.stdlib.library.getSingleton().setLastError(e.toString());
  }
  return null;
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
private boolean connectToSocket() {
	if (initialized)
		return true;
	try {
		comm = (SocketConnection)Connector.open(address, Connector.READ_WRITE);
		inputStream = comm.openInputStream();
		outputStream = comm.openOutputStream();
		initialized = true;
		BlackBoxProtocol.log("Successfully connected to " + address);
	} catch (IOException ex) {
		BlackBoxProtocol.log("Failed to connect to " + address);
		initialized = false;
	}
	return initialized;
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
/**
 * Check a socket option to make sure it's a valid option.
 *
 * @param option socket option identifier (KEEPALIVE, LINGER, 
 * SNDBUF, RCVBUF, or DELAY)
 * @exception  IllegalArgumentException if  the value is not 
 *              valid (e.g. negative value)
 *              
 * @see #getSocketOption
 * @see #setSocketOption
 */
private void checkOption(byte option) 
    throws IllegalArgumentException {
    if (option == SocketConnection.KEEPALIVE 
        || option == SocketConnection.LINGER 
        || option == SocketConnection.SNDBUF 
        || option == SocketConnection.RCVBUF 
        || option == SocketConnection.DELAY) {
        return;
    }
    throw new IllegalArgumentException("Unsupported Socket Option");
        
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
/**
 * Create the underlying network TCP connection.
 *
 * @param url the url of connection
 * @return network stream connection
 * @exception IOException is thrown if the connection cannot be opened
 */
private com.sun.midp.io.j2me.socket.Protocol createConnection(String url)
    throws IOException {
    com.sun.midp.io.j2me.socket.Protocol conn =
        new com.sun.midp.io.j2me.socket.Protocol();

    conn.openPrim(classSecurityToken, url);

    // Do not delay request since this delays the response.
    conn.setSocketOption(SocketConnection.DELAY, 0);

    return conn;
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
OBEXTCPServiceRecordImpl(SocketConnection connection) {
	try {
		port = String.valueOf(connection.getPort());
		host = connection.getAddress();
	} catch (IOException e) {
		host = null;
	}
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
public synchronized void connect() throws IOException {
    m_socket = (SocketConnection) Connector.open(url);//, Connector.READ_WRITE, true);
    m_is = m_socket.openInputStream();
    m_os = m_socket.openOutputStream();
    m_connected = true;
    
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
public void establishConnection(String host, int port) {
this.host = host;
this.port = port;
running = connected = false;
socketListeners = new Vector();
try {
	connection = ((SocketConnection) (Connector.open("socket://" + host
			+ ":" + port)));
} catch (IOException e) {
	e.printStackTrace();
	connection = null;
}

  }
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
public void connect() throws IOException {
	this.sc = (SocketConnection) Connector.open("socket://" + this.ip + ":" + this.port);
	sc.setSocketOption(SocketConnection.LINGER, 5);

	this.is = sc.openInputStream();
	this.os = sc.openOutputStream();

	this.isConnected = true;
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
/**
 * Connect to the underlying network TCP transport.
 * If the proxy is configured, connect to it as tunnel first.
 * <p>
 * Warning: A subclass that implements this method, should not call this
 * method and should implement the disconnect method.
 *
 * @return network stream connection
 * @exception IOException is thrown if the connection cannot be opened
 */
protected StreamConnection connect() throws IOException {
    StreamConnection sc;
    com.sun.midp.io.j2me.socket.Protocol conn;

    if (!permissionChecked) {
        throw new SecurityException();
    }

    sc = connectionPool.get(classSecurityToken, protocol,
                                          url.host, url.port);

    if (sc != null) {
        return sc;
    }

    conn = new com.sun.midp.io.j2me.socket.Protocol();

    if (http_proxy == null || url.host.equals("localhost") ||
        url.host.equals("127.0.0.1")) {
        /* bypass proxy when trying to connect to the same computer
         * and not using explicit IP or host name */
        conn.openPrim(classSecurityToken, "//" + hostAndPort);

        // Do not delay request since this delays the response.
        conn.setSocketOption(SocketConnection.DELAY, 0);
        return conn;
    }
  
    conn.openPrim(classSecurityToken, "//" + http_proxy);

    // Do not delay request since this delays the response.
    conn.setSocketOption(SocketConnection.DELAY, 0);

    // openData*Stream cannot be call twice, so save them for later
    streamOutput = conn.openDataOutputStream();
    streamInput = conn.openDataInputStream();

    try {
        doTunnelHandshake(streamOutput, streamInput);
    } catch (IOException ioe) {
        String response = ioe.getMessage();

        try {
            disconnect(conn, streamInput, streamOutput);
        } catch (Exception e) {
            // do not over throw the handshake exception
        }

        streamOutput = null;
        streamInput = null;

        if ((response != null) && (response.indexOf(" 500 ") > -1)) {
            throw new ConnectionNotFoundException(response);
        } else {
            throw ioe;
        }
    }

    return conn;
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
public VisionServerConnectionHandler(SocketConnection c) {
  connection = c;
}
 

import javax.microedition.io.SocketConnection; //导入依赖的package包/类
public VisionServerConnectionHandler(final SocketConnection c) {
    connection = c;
}