Indicates whether this XMLSocket object is currently connected. You can also check whether the connection succeeded by registering for the connect event and ioError event.

See also

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 XMLSocket 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.

See also

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

See also

Establishes a connection to the specified Internet host using the specified TCP port.

If you specify null for the host parameter, the host contacted is the one where the file calling XMLSocket.connect() resides. For example, if the calling file was downloaded from www.adobe.com, specifying null for the host parameter means you are connecting to www.adobe.com.

You can prevent a file from using this method by setting the allowNetworking parameter of the the object and embed tags in the HTML page that contains the SWF content.

For more information, see the Flash Player Developer Center Topic: Security.

See also

Converts the XML object or data specified in the object parameter to a string and transmits it to the server, followed by a zero (0) byte. If object is an XML object, the string is the XML textual representation of the XML object. The send operation is asynchronous; it returns immediately, but the data may be transmitted at a later time. The XMLSocket.send() method does not return a value indicating whether the data was successfully transmitted.

If you do not connect the XMLSocket object to the server using XMLSocket.connect()), the XMLSocket.send() operation fails.

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 XMLSocket.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 after a successful call to the XMLSocket.connect() method.

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

This event has the following properties:

Dispatched after raw data is sent or received.

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

This event has the following properties:

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

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

This event has the following properties:

Dispatched if a call to the XMLSocket.connect() method attempts to connect either to a server outside the caller's security sandbox or to a port lower than 1024.

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

1. The XMLSocketExample constructor creates a XMLSocket instance named socket and passes socket to ConfigureListeners() (described below) and then calls the connect() method of XMLSocket using the host name "localhost" and port number of 8080.
2. The configureListeners() method is then called, which adds listeners for each of the supported XMLSocket events:
   • closeHandler(): listens for the close event, which is dispatched after the network connection has been closed.
   • connectHandler(): listens for the connect event, dispatched when the network connection has been established.
   • dataHandler(): listens for the data events, dispatched every time the XMLSocket receives new data.
   • progressHandler(): listens for the progress events, dispatched when a call to send() has been made and while the send is ongoing.
   • securityErrorHandler(): listens for securityError events, which would be dispatched if an attempt was made to access the XMLSocket with the wrong local playback security setting or using a port lower than 1024.
   • ioErrorHandler(): listens for ioError events, which would happen only if an operation to send or receive data failed.

Notes:

• You need to compile the SWF file with "Local playback security" set to "Access network only".
• You need a server running on your domain using port 8080 for this example to work.
• If you are running Flash Player 9.0.124.0 or later, you need to place a socket policy file on your server that permits socket connections from your domain to port 8080. For information on serving socket policy files, see the Flash Player Developer Center Topic: Setting up a socket policy file server.

package {
    import flash.display.Sprite;
    import flash.events.*;
    import flash.net.XMLSocket;

    public class XMLSocketExample extends Sprite {
        private var hostName:String = "localhost";
        private var port:uint = 8080;
        private var socket:XMLSocket;

        public function XMLSocketExample() {
            socket = new XMLSocket();
            configureListeners(socket);
            if (hostName && port) {
                socket.connect(hostName, port);
            }
        }

        public function send(data:Object):void {
            socket.send(data);
        }

        private function configureListeners(dispatcher:IEventDispatcher):void {
            dispatcher.addEventListener(Event.CLOSE, closeHandler);
            dispatcher.addEventListener(Event.CONNECT, connectHandler);
            dispatcher.addEventListener(DataEvent.DATA, dataHandler);
            dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
            dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler);
            dispatcher.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
        }

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

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

        private function dataHandler(event:DataEvent):void {
            trace("dataHandler: " + event);
        }

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

        private function progressHandler(event:ProgressEvent):void {
            trace("progressHandler loaded:" + event.bytesLoaded + " total: " + event.bytesTotal);
        }

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