Socket.writeBytes();

package artshlagin.network 

{

        import flash.events.DataEvent;

        import flash.events.Event;

        import flash.events.IOErrorEvent;

        import flash.events.ProgressEvent;

        import flash.events.SampleDataEvent;

        import flash.events.SecurityErrorEvent;

        import flash.net.Socket;

        import flash.utils.ByteArray;

 

        /**

         * ...

         * @author Artem Shlagin

         */

 

        [Event(name = "sampleData", type = "flash.events.SampleDataEvent")]

 

        public class BinarySocket extends Socket

        {

                /**

                 * Два байта выделять под заголовок (true) или один (false)

                 */

                public static var HEADER_BYTES_DOUBLE:Boolean = true;

 

                /**

                 * Два байта выделять под заголовок (true) или один (false)

                 */

                public static var MESSAGE_LENGTH_DOUBLE:Boolean = true;

 

 

                private var _responseByteArray:ByteArray;

                private var _messageLength:uint;

 

                /**

                 * Класс для обмена бинарными данными с сокет-сервером

                 * @param        host

                 * @param        port

                 */

                public function BinarySocket(host:String = null, port:int = 0) 

                {

                        super(host, port);

                        super.addEventListener(Event.CONNECT, onConnect);

 

                        _messageLength = 0;

                        _responseByteArray = new ByteArray();

                }

 

                public function send(packet:uint, message:ByteArray = null):void {

                        HEADER_BYTES_DOUBLE ? super.writeShort(packet) : super.writeByte(packet);

                        if (message) {

                                var l:uint = message.length;

                                MESSAGE_LENGTH_DOUBLE ? super.writeShort(l) : super.writeByte(l);

                                super.writeBytes(message);

                        }

                        else MESSAGE_LENGTH_DOUBLE ? super.writeShort(0) : super.writeByte(0);

                        super.flush();

                }

                private function onConnect(event:Event):void 

                {

                        super.addEventListener(ProgressEvent.SOCKET_DATA, onSocketData);

                }

 

                protected function onSocketData(event:ProgressEvent):void 

                {

                        var ba:uint;

                        var headerBytes:uint = HEADER_BYTES_DOUBLE ? 2 : 1;

                        var messageBytes:uint = MESSAGE_LENGTH_DOUBLE ? 2 : 1;

                        do {

 

                                ba = super.bytesAvailable;

                                if (_messageLength > 0) { //reading message

                                        if (ba >= _messageLength) {

                                                super.readBytes(_responseByteArray, headerBytes, _messageLength);

                                                flushToClient();

                                        }

                                        else return; //reading only a full message, or wait

                                }

                                else{

                                        if (_responseByteArray.length >= headerBytes) { //header passed

                                                if (ba >= messageBytes) { //reading message length if can

                                                        _messageLength = MESSAGE_LENGTH_DOUBLE ? super.readUnsignedShort() : super.readUnsignedByte();

                                                        if (!_messageLength) flushToClient(); //if no message

                                                }

                                                else return; // or waiting to load full length

                                        }

 

                                        else { // if header is not passed - reading

                                                if (ba >= headerBytes) { //reading header if can

                                                        super.readBytes(_responseByteArray, 0, headerBytes);

                                                }

                                                else return; //or waiting to load full header

                                        }

                                }

 

                        }

 

                        while (super.bytesAvailable); //NOT ba, мы считывали байты после калькуляции ba

 

                }

 

                /**

                 * Отправляет данные клиенту

                 */

                protected function flushToClient():void {

                        _messageLength = 0;

                        var event:SampleDataEvent = new SampleDataEvent(SampleDataEvent.SAMPLE_DATA);

                        _responseByteArray.position = 0;

                        event.data = _responseByteArray;

                        _responseByteArray = new ByteArray();

                        super.dispatchEvent(event);

 

                }

 

        }

 

}