The number of bytes of data available for reading in the input buffer.

Your code must access bytesAvailable to ensure that sufficient data is available before trying to read it with one of the read methods.

Indicates the number of bytes remaining in the write buffer.

Use this property in combination with with the OutputProgressEvent. An OutputProgressEvent is thrown whenever data is written from the write buffer to the network. In the event handler, you can check bytesPending to see how much data is still left in the buffer waiting to be written. When bytesPending returns 0, it means that all the data has been transferred from the write buffer to the network, and it is safe to do things like remove event handlers, null out socket references,start the next upload in a queue, etc.

See also

Indicates whether this Socket object is currently connected. A call to this property returns a value of true if the socket is currently connected, or false otherwise.

Indicates the byte order for the data. Possible values are constants from the flash.utils.Endian class, Endian.BIG_ENDIAN or Endian.LITTLE_ENDIAN.

The default value is Endian.BIG_ENDIAN.

See also

The IP address this socket is bound to on the local machine.

See also

The port this socket is bound to on the local machine.

See also

Controls the version of AMF used when writing or reading an object.

See also

The IP address of the remote machine to which this socket is connected.

You can use this property to determine the IP address of a client socket dispatched in a ServerSocketConnectEvent by a ServerSocket object. Use the DNSResolver class to convert an IP address to a domain name, if desired.

See also

The port on the remote machine to which this socket is connected.

You can use this property to determine the port number of a client socket dispatched in a ServerSocketConnectEvent by a ServerSocket object.

See also

Whether to use the 'TCP_NODELAY' setting to avoid the use of Nagle's algorithm.

If this value is set, data will be sent as soon as it's ready, to reduce latency (good for situations where lots of small data package are expected). If this is false then Nagle's algorithm will be applied to the socket which means that data will be grouped together into more efficient data transfer packets, but in a way that can add delays.

Indicates the number of milliseconds to wait for a connection.

If the connection doesn't succeed within the specified time, the connection fails. The default value is 20,000 (twenty seconds).

Creates a new Socket object. If no parameters are specified, an initially disconnected socket is created. If parameters are specified, a connection is attempted to the specified host and port.

Note: It is strongly advised to use the constructor form without parameters, then add any event listeners, then call the connect method with host and port parameters. This sequence guarantees that all event listeners will work properly.

Closes the socket. You cannot read or write any data after the close() method has been called.

The close event is dispatched only when the server closes the connection; it is not dispatched when you call the close() method.

You can reuse the Socket object by calling the connect() method on it again.

Connects the socket to the specified host and port.

If the connection fails immediately, either an event is dispatched or an exception is thrown: an error event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise, the status of the connection is reported by an event. If the socket is already connected, the existing connection is closed first.

Flushes any accumulated data in the socket's output buffer.

On some operating systems, flush() is called automatically between execution frames, but on other operating systems, such as Windows, the data is never sent unless you call flush() explicitly. To ensure your application behaves reliably across all operating systems, it is a good practice to call the flush() method after writing each message (or related group of data) to the socket.

Reads a Boolean value from the socket. After reading a single byte, the method returns true if the byte is nonzero, and false otherwise.

Reads a signed byte from the socket.

Reads the number of data bytes specified by the length parameter from the socket. The bytes are read into the specified byte array, starting at the position indicated by offset.

Reads an IEEE 754 double-precision floating-point number from the socket.

Reads an IEEE 754 single-precision floating-point number from the socket.

Reads a signed 32-bit integer from the socket.

Reads a multibyte string from the byte stream, using the specified character set.

Reads an object from the socket, encoded in AMF serialized format.

See also

Reads a signed 16-bit integer from the socket.

Reads an unsigned byte from the socket.

Reads an unsigned 32-bit integer from the socket.

Reads an unsigned 16-bit integer from the socket.

Reads a UTF-8 string from the socket. The string is assumed to be prefixed with an unsigned short integer that indicates the length in bytes.

Reads the number of UTF-8 data bytes specified by the length parameter from the socket, and returns a string.

Writes a Boolean value to the socket. This method writes a single byte, with either a value of 1 (true) or 0 (false).

See also

Writes a byte to the socket.

See also

Writes a sequence of bytes from the specified byte array. The write operation starts at the position specified by offset.

If you omit the length parameter the default length of 0 causes the method to write the entire buffer starting at offset.

If you also omit the offset parameter, the entire buffer is written.

See also

Writes an IEEE 754 double-precision floating-point number to the socket.

See also

Writes an IEEE 754 single-precision floating-point number to the socket.

See also

Writes a 32-bit signed integer to the socket.

See also

Writes a multibyte string from the byte stream, using the specified character set.

See also

Write an object to the socket in AMF serialized format.

See also

Writes a 16-bit integer to the socket. The bytes written are as follows:

(v >> 8) & 0xff v & 0xff

The low 16 bits of the parameter are used; the high 16 bits are ignored.

See also

Writes a 32-bit unsigned integer to the socket.

See also

Writes the following data to the socket: a 16-bit unsigned integer, which indicates the length of the specified UTF-8 string in bytes, followed by the string itself.

Before writing the string, the method calculates the number of bytes that are needed to represent all characters of the string.

See also

Writes a UTF-8 string to the socket.

See also

Dispatched when the server closes the socket connection.

The close event is dispatched only when the server closes the connection; it is not dispatched when you call the Socket.close() method.

The Event.CLOSE constant defines the value of the type property of a close event object.

This event has the following properties:

Dispatched when a network connection has been established.

The Event.CONNECT constant defines the value of the type property of a connect event object.

This event has the following properties:

Dispatched when an input/output error occurs that causes a send or load operation to fail.

Defines the value of the type property of an ioError event object.

This event has the following properties:

Dispatched when a socket moves data from its write buffer to the networking transport layer

Dispatched if a call to Socket.connect() attempts to connect to a server prohibited by the caller's security sandbox or to a port lower than 1024 and no socket policy file exists to permit such a connection.

Note: In an AIR application, content running in the application security sandbox is permitted to connect to any server and port number without a socket policy file.

The SecurityErrorEvent.SECURITY_ERROR constant defines the value of the type property of a securityError event object.

This event has the following properties:

See also

Dispatched when a socket has received data.

The data received by the socket remains in the socket until it is read. You do not have to read all the available data during the handler for this event.

Events of type socketData do not use the ProgressEvent.bytesTotal property.

Defines the value of the type property of a socketData event object.

This event has the following properties:

1. The constructor creates a CustomSocket instance named socket and passes the host name localhost and port 80 as arguments. Since CustomSocket extends Socket, a call to super() calls Socket's constructor.
2. The example then calls the configureListeners() method, which adds listeners for Socket events.
3. Finally, the socket connect() method is called with localhost as the host name and 80 as the port number.

Note: To run the example, you need a server running on the same domain where the SWF resides (in the example, localhost) and listening on port 80.

package {
	import flash.display.Sprite;

	public class SocketExample extends Sprite {
		private var socket:CustomSocket;
		
		public function SocketExample() {
			socket = new CustomSocket("localhost", 80);
		}
	}
}

import flash.errors.*;
import flash.events.*;
import flash.net.Socket;

class CustomSocket extends Socket {
	private var response:String;

	public function CustomSocket(host:String = null, port:uint = 0) {
		super();
		configureListeners();
		if (host && port)  {
			super.connect(host, port);
		}
	}

	private function configureListeners():void {
		addEventListener(Event.CLOSE, closeHandler);
		addEventListener(Event.CONNECT, connectHandler);
		addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
		addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
		addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
	}

	private function writeln(str:String):void {
		str += "\n";
		try {
			writeUTFBytes(str);
		}
		catch(e:IOError) {
			trace(e);
		}
	}

	private function sendRequest():void {
		trace("sendRequest");
		response = "";
		writeln("GET /");
		flush();
	}

	private function readResponse():void {
		var str:String = readUTFBytes(bytesAvailable);
		response += str;
	}

	private function closeHandler(event:Event):void {
		trace("closeHandler: " + event);
		trace(response.toString());
	}

	private function connectHandler(event:Event):void {
		trace("connectHandler: " + event);
		sendRequest();
	}

	private function ioErrorHandler(event:IOErrorEvent):void {
		trace("ioErrorHandler: " + event);
	}

	private function securityErrorHandler(event:SecurityErrorEvent):void {
		trace("securityErrorHandler: " + event);
	}

	private function socketDataHandler(event:ProgressEvent):void {
		trace("socketDataHandler: " + event);
		readResponse();
	}
}