Question

I am having an issue with sockets where the data I’m sending is getting truncated on the client side (Flash/Flex). The data that is sent by my server is full and in tact, but flash does not wait the appropriate amount of time before firing an event saying to read the data. This results in the data not getting fully read and (as such) I can’t parse the object out of it after that. We are exploring the possibility of stripping the object into smaller chunks, but the idea is for it to be as lightweight as possible so we would much rather get it to work the way it’s supposed to than patch in a temporary solution.

I’m not entirely sure if referring to it as the receive ‘buffer’ is correct, as some computers are able to receive all of the data and others are having it truncated (which means the buffer is adequate but flash isn’t waiting the appropriate amount of time to dispatch the event for whatever the reason)…If anyone has any ideas I would greatly appreciate them!

Answer 1

Without seeing code of your implementation, it sounds like bytes available or total bytes are not being accounted for.

Here is an implementation I have used:

package
{
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.IOErrorEvent;
    import flash.events.ProgressEvent;
    import flash.events.SecurityErrorEvent;
    import flash.net.Socket;

    public class WebRequestService extends EventDispatcher
    {

        //------------------------------
        //  model
        //------------------------------

        protected var hostname:String;

        protected var port:uint;

        public var requestMessage:String;

        public var responseMessage:String;

        private var _socket:Socket;


        //------------------------------
        //  lifecycle
        //------------------------------

        public function WebRequestService(hostname:String, port:uint, requestMessage:String)
        {
            this.hostname = hostname;
            this.port = port;
            this.requestMessage = requestMessage;

            _socket = new Socket();
            _socket.addEventListener(Event.CONNECT, socketConnectHandler);
            _socket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
            _socket.addEventListener(Event.CLOSE, socketCloseHandler);
            _socket.addEventListener(IOErrorEvent.IO_ERROR, socketErrorHandler);
            _socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, socketSecurityErrorHandler);

            _socket.connect(hostname, port);
        }

        protected function socketConnectHandler(event:Event):void
        {
            responseMessage = "";
            _socket.writeUTFBytes(requestMessage);
            _socket.flush();
        }

        protected function socketDataHandler(event:ProgressEvent):void
        {
            while (_socket.bytesAvailable > 4)
            {
                responseMessage += _socket.readUTFBytes(_socket.bytesAvailable);
            }
        }

        protected function socketCloseHandler(event:Event):void
        {
            dispose();
        }

        protected function socketErrorHandler(event:IOErrorEvent):void
        {
            trace("socket error.");
        }

        protected function socketSecurityErrorHandler(event:SecurityErrorEvent):void
        {
            trace("socket security error.");
        }

        public function dispose():void
        {
            if (!_socket)
                return;

            if (_socket.connected)
                _socket.close();

            _socket.removeEventListener(Event.CONNECT, socketConnectHandler);
            _socket.removeEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
            _socket.removeEventListener(Event.CLOSE, socketCloseHandler);
            _socket.removeEventListener(IOErrorEvent.IO_ERROR, socketErrorHandler);
            _socket.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, socketSecurityErrorHandler);
        }

    }
}