socket通信

package gamePub.clientSocket
{        
        import flash.events.Event;
        import flash.events.IOErrorEvent;
        import flash.events.ProgressEvent;
        import flash.events.SecurityErrorEvent;
        import flash.net.Socket;
        import flash.text.TextField;
        import flash.text.TextFormat;
        import flash.utils.ByteArray;
        
        import gamePub.ui.GPopInfo;
        
        import gsocket.GlobalManagement;
        


        public class ClientSocket extends Socket
        {
                public function ClientSocket(host:String=null, port:int=0)
                {
                        super(host, port);
                        addEventListener(Event.CONNECT, connectHandler);
            addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
            addEventListener(Event.CLOSE,onServerClosed);
            addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
                    addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
                }
                
                private var _readyToSend:Boolean = false;
                public function get readyToSend():Boolean
                {
                        return _readyToSend;
                }
                
                private var _readyToClose:Boolean = false;
                public function get readyToClose():Boolean
                {
                        return _readyToClose;
                }
                
                private var _readyToConnect:Boolean = true;
                public function get readyToConnect():Boolean
                {
                        return _readyToConnect;
                }
                
                //成功建立和服务端得连接后
        private function connectHandler(event:Event):void 
        {
            _readyToConnect = false;
            _readyToSend = _readyToClose= true;
           trace("connectHandler");
        }
        
        public var readyToRecv:Boolean = false;        //可以接受数据
        //成功接收到从服务端传来的一次数据
        private function socketDataHandler(event:ProgressEvent):void 
        {
                //trace("ClientSocket socketDataHandler");
            readyToRecv = true;
            var recvStream:ByteArray = new ByteArray();
            readBytes(recvStream,0,bytesAvailable);
            GlobalManagement.instance.recvMessageFromServer(recvStream);
        }
        
        //关闭套接字
        public function closeClientSocket():void
        {
            if(this && connected)
            {
                removeEventListener(Event.CONNECT, connectHandler);
                removeEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
                removeEventListener(Event.CLOSE,onServerClosed);
                removeEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
                        removeEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
                close();
            }
            _readyToConnect = true;
            _readyToSend = _readyToClose = false;
        }
        
        //服务端关闭后
        private function onServerClosed(event:Event):void
        {
                trace("onServerClosed");
                        
                closeClientSocket();
        }
        
        private function ioErrorHandler(event:IOErrorEvent):void
        {
                trace("ioErrorHandler");
                closeClientSocket();
        }
        
        private function securityErrorHandler(event:SecurityErrorEvent):void
        {
                closeClientSocket();
                trace("security错误");
        }
        }
}

 

 

 

package gamePub.clientSocket
{
        
        import pub.net.NetCenter;
        
        import flash.utils.ByteArray;
        import flash.utils.Endian;

        public class NetManagement
        {
                private static var _instance:NetManagement;                
                public static function get instance():NetManagement
                {
                        if(!_instance)
                        {
                                _instance = new NetManagement();
                        }
                        return _instance;
                }                
                private var _partData:ByteArray = new ByteArray();        //过长或者过短的数据包 _partData
                private var _packageQueue:Array = [];        //数据包队列 存放ByteArray类型的元素
                //填充需要处理的消息队列_packageQueue  参数value是服务器发送过来的字节流
                private function fillMsgQueue(value:ByteArray):void
                {
                        _partData.position = _partData.length;
                        _partData.writeBytes(value);
                        //value追加到_partData末尾
                        //处理_partData,使得_partData中没有数据包或者只有一个过短的数据包
                        var otherPack:PackageHead = new PackageHead();
                        otherPack.byteArray = _partData;
                        //无包头
                        if(!otherPack.legal)        
                        {
                                ////trace("断包 无包头");
                                _partData = new ByteArray();
                        }
                        while(otherPack.legal)
                        {
                                if(otherPack.bodyLen < otherPack.body.length)
                                {
                                        var pack2:ByteArray = new ByteArray();
                                        pack2.writeBytes(_partData,0,otherPack.bodyLen+6);
                                        _packageQueue.push(pack2);
                                        //trace("连包");
//                                        var pck:PackageHead = new PackageHead();
//                                        pck.byteArray = pack2;
//                                        //trace("fillMsgQueue len cmd",pck.toByteArray().length,pck.cmd.toString(16));
                                        var pack3:ByteArray = new ByteArray();
                                        pack3.writeBytes(_partData,pack2.length);
                                        _partData = pack3;
                                        otherPack.byteArray = _partData;
                                }
                                else if(otherPack.bodyLen == otherPack.body.length)
                                {
                                        _packageQueue.push(otherPack.toByteArray());
                                //        //trace("fillMsgQueue len cmd",otherPack.toByteArray().length,otherPack.cmd.toString(16));
                                        _partData = new ByteArray();        //清空_partData
                                        break;
                                }
                                else
                                {
                                        //trace("断包 有包头");
                                        break;
                                }
                        }
                }
                
                //服务器发信息到客户端,有可能去改变可视元素的关联数据
                public function recvMessageFromServer(value:ByteArray):void
                {
                        fillMsgQueue(value);
                        while(_packageQueue.length > 0)
                        {
                                var pack:ByteArray = _packageQueue.shift();
                                processServerMsg(pack);
                        }
                }
                //处理服务器发过来的正确数据包,value是长度正确的一个数据包
                private function processServerMsg(value:ByteArray):void
                {
                        var pack:PackageHead = new PackageHead();
                        pack.byteArray = value;
                        //trace("processServerMsg pack len,command",pack.toByteArray().length,pack.cmd);
                        var cmd:uint;        //命令字
                        cmd = pack.cmd;
                        //trace("pack cmd",cmd.toString(16));
                        pack.body.endian = Endian.LITTLE_ENDIAN;
                        pack.body.position = 0;
                        //判断数据完整
                        NetCenter.onReceivedMessage(cmd,pack.body); //分发消息
                }
                
/*                public function useItemUpLevel(page:int,grid:int,id:Array):void
                 {
                         var body:ByteArray = new ByteArray();
                        body.endian = Endian.LITTLE_ENDIAN;
                        
                        body.writeByte(page)        
                        body.writeByte(grid)
                        body.writeInt(id[0])
                        body.writeInt(id[1])
                        
                        var pack:PackageHead = new PackageHead(body);
                        pack.cmd = CommandEnum.CLGM_USEITEM_UPLEVEL_SHOP
                        pack.sendMsg()
                 }*/
        }
}

 

 

package gamePub.clientSocket
{
        
        import pub.net.NetCenter;
        
        import flash.utils.ByteArray;
        import flash.utils.Endian;
        
        public class PackageHead
        {        
                
                private const HEAD_FLAG:uint = 0xFFAA;
                
                private var _headFlag:uint;                //标志位 unsigned short 用于辨别数据包的真伪
                
                public static const MAX_SIZE:uint = 119;
                
                public var cmd:uint = CommandEnum.CLGM_CHAT;        //命令字  用于区分数据包的类型，邮件包还是聊天包？
                
                private var _body:ByteArray;                //和消息包头关联的消息包体
                private var _legal:Boolean = true;        //数据是否合法，默认合法
                private var _bodyLen:uint;
                
                public function PackageHead(msg:ByteArray=null)
                {
                        _headFlag = HEAD_FLAG;
                        _body = msg;
                }
                
                public function get body():ByteArray
                {
                        return _body;
                }
                
                public function get legal():Boolean
                {
                        return _legal;
                }
                
                
                public function get bodyLen():uint
                {
                        return _bodyLen;
                }
                
                public function set byteArray(value:ByteArray):void
                {
                        if(value)
                        {
                                value.position = 0;
                                value.endian = Endian.LITTLE_ENDIAN;
                                _headFlag = value.readUnsignedShort();
                                if(_headFlag != HEAD_FLAG)
                                {
                                        _legal = false;
                                        return ;
                                }
                                cmd = value.readUnsignedShort();
                                _bodyLen = value.readUnsignedShort();
                                _body = new ByteArray();
                                _body.writeBytes(value,6,value.length-6);
                        }
                }
                
                public function toByteArray():ByteArray                //把packageHead转换为对应的ByteArray
                {
                        var byteStream:ByteArray = new ByteArray();
                byteStream.endian = Endian.LITTLE_ENDIAN;
                byteStream.writeShort(HEAD_FLAG);
                byteStream.writeShort(cmd);
                if(_body)
                {
                        byteStream.writeShort(_body.length);
                        byteStream.writeBytes(_body);
                }
                else
                {
                        byteStream.writeShort(0);
                }
                        return byteStream;
                }
                
                //发送消息包给服务器 发送成功返回true
                public function sendMsg():Boolean
                {
                        if(NetCenter.m_clientSocket && NetCenter.m_clientSocket.connected)
                        {
                                NetCenter.m_clientSocket.writeBytes(toByteArray(),0,toByteArray().length);
                                NetCenter.m_clientSocket.flush();
//                                trace("sendMsg:true");

                                return true;
                        }
//                        trace("sendMsg:false");
                        return false;
                }
        }
}