Бинарные сокеты в AS3. Часть 3

Код AS3:

_socket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
_lastComSize = 0;
...
private function socketDataHandler(e:ProgressEvent):void 
{
	// Пришли данные, рассматриваем три варианта:
	while (_socket.bytesAvailable)
	{
		// Вариант №1: мы ждали новый пакет, о чем свидетельствует
		// то, что нам не известен размер текущего (последнего)
		// пакета.
		if (!_lastComSize)
		{
			// Читаем размер в том случае если можем его прочитать.
			if (_socket.bytesAvailable >= 2)
				_lastComSize = _socket.readShort();
			// Если не можем, уходим из цикла и из функции,
			// до прихода следующих данных.
			else
				break;
			// Здесь оказываемся если длина пакета успешно считана.
			// Если нам повезло и пакет пришел целиком...
			if (_socket.bytesAvailable >= _lastComSize)
			{
				// ...парсим его. В конце функции parse() переменная
				// _lastComSize выставляется в ноль, что свидетельствует
				// об окончании парсинга одного пакета.
				parse();
				// После этого парсинга или того, что будет в Варианте №2,
				// благодаря циклу while, попытка обработки пришедших
				// данных запустится еще раз. На случай если нам
				// за один раз пришло более одного пакета.
			}
		}
		// Вариант №2: мы ждали окончания пакета, начало которого было
		// в одном из предыдущих вызовов функции socketDataHandler().
		// Если на этот раз байт пришло достаточно, начинаем парсить.
		else if (_socket.bytesAvailable >= _lastComSize)
		{
			parse();
		}
		// Вариант №3: мы также как и во втором варианте дожидаемся
		// окончания пакета, но даже с этой пачкой данных он все равно
		// пришел не полностью. В таком случае просто выходим из функции
		// и ждем еще байтов.
		else
			break;
	}
}
 
private function parse():void
{
	// parse() вызывается только в том случае, когда нам
	// точно известно, что очередной пакет пришел полностью,
	// поэтому можно его смело обрабатывать.
	// Читаем id команды.
	var comId:int = _socket.readShort();
	// И вызываем соответствующую функцию.
	switch(comId)
	{
		case S_READY: readyHandler(); break;
		case S_NO_ROOM: noRoomHandler(); break;
		...
		case S_END_GAME: endGameHandler(); break;
	}
	// Как и было сказано выше, устанавливаем флаг окончания
	// парсинга пакета.
	_lastComSize = 0;
}

Код AS3:

switch(comId)
	{
		case S_READY: readyHandler(); break;
		case S_NO_ROOM: noRoomHandler(); break;
		...
		case S_END_GAME: endGameHandler(); break;
	}

Код AS3:

//game-list
			_sock.registerParser(Parsers.gl_add);
			_sock.registerParser(Parsers.gl_remove);
			_sock.registerParser(Parsers.gl_update);
			_sock.registerParser(Parsers.gc_create);

Код AS3:

//handlers
			_strategy = new Strategy();
			_strategy.registerMethod(Parsers.decline.name, onDeclineCommand);
			_strategy.registerMethod(Parsers.regresp.name, onRegAccept)
			_strategy.registerMethod(Parsers.ul_join.name, onJoinUser);
			_strategy.registerMethod(Parsers.ul_remove.name, onRemoveUser);
			_strategy.registerMethod(Parsers.ul_player_info.name, onPlayerInfo);
			_strategy.registerMethod(Parsers.chat_say.name, onChatMessage);

Код AS3:

private function onResponse(e:ResponseEvent):void 
		{
			_strategy.execute(e.response);
		}

Код AS3:

package protocol.parsers.list.chat 
{
	import flash.utils.ByteArray;
	import io.SeabattleByteArray;
	import protocol.packets.list.chat.PlayerInfoResp;
	import ramshteks.as3.cozy.interfaces.IParser;
	import ramshteks.as3.cozy.interfaces.IResponse;
 
	/**
	 * ...
	 * @author Shirobok Pavel (ramshteks@gmail.com)
	 */
	public class PlayerInfoRespParser implements IParser 
	{
 
		public function PlayerInfoRespParser() 
		{
 
		}
 
		/* INTERFACE ramshteks.as3.cozy.interfaces.IParser */
 
		public function parse(bytes:ByteArray):IResponse 
		{
			var ba:SeabattleByteArray = SeabattleByteArray.getInstance(bytes);
 
			return new PlayerInfoResp(command, name, ba.read_player_info());
		}
 
		public function get command():int 
		{
			return 13;
		}
 
		public function get name():String 
		{
			return "PlayerInfoResp";
		}
 
	}
 
}

/**
  * Be man, implement this
  *
  * @param arg object
  */

Код AS3:

package client.net.packets {
	import flash.utils.ByteArray;
 
	/**
	 * @author KorDum
	 */
 
	public class PacketByteArray extends ByteArray {
 
		//---------------------------------------------------------------------------
		//
		// CONSTRUCTOR
		//
		//---------------------------------------------------------------------------
 
		public function PacketByteArray() {
 
		}
 
 
		//---------------------------------------------------------------------------
		//
		// PUBLIC METHODS
		//
		//---------------------------------------------------------------------------
 
		public function writeLength(value:uint):void {
			writeInt(value);
		}
 
 
		public function writeType(value:uint):void {
			writeByte(value);
		}
 
 
		public function writeCommand(value:uint):void {
			writeShort(value);
		}
 
 
		public function writeIdRoom(value:uint):void {
			writeInt(value);
		}
 
 
		public function readLength():uint {
			return readInt();
		}
 
 
		public function readType():uint {
			return readByte();
		}
 
 
		public function readCommand():uint {
			return readShort();
		}
 
 
		public function readIdRoom():uint {
			return readInt();
		}
 
 
		public function readMessage():String {
			if (!bytesAvailable) {
				return null;
			}
 
			return readUTFBytes(bytesAvailable);
		}
	}
}

Код AS3:

package client.net.packets {
 
	/**
	 * @author KorDum
	 */
 
	public class SystemPacket extends Packet {
		private var _command:uint;
		private var _message:String;
 
		//---------------------------------------------------------------------------
		//
		// CONSTRUCTOR
		//
		//---------------------------------------------------------------------------
 
		public function SystemPacket() {
			type = Packet.SYSTEM;
		}
 
 
		//---------------------------------------------------------------------------
		//
		// PUBLIC STATIC METHODS
		//
		//---------------------------------------------------------------------------
 
		public static function createByData(length:uint, data:PacketByteArray):SystemPacket {
			var packet:SystemPacket = new SystemPacket();
 
			packet.data = data;
			packet.length = length;
			packet.command = data.readCommand();
			packet.message = data.readMessage();
 
			return packet;
		}
 
 
		public static function createByCommand(command:uint):SystemPacket {
			var packet:SystemPacket = new SystemPacket();
 
			var buffer:PacketByteArray = new PacketByteArray();
			buffer.writeCommand(command);
 
			packet.data = buffer;
			packet.length = buffer.length;
			packet.command = command;
 
			return packet;
		}
 
 
		public static function createByCommandMessage(command:uint, message:String):SystemPacket {
			var packet:SystemPacket = new SystemPacket();
 
			var buffer:PacketByteArray = new PacketByteArray();
			buffer.writeCommand(command);
			buffer.writeUTFBytes(message);
 
			packet.data = buffer;
			packet.length = buffer.length;
			packet.command = command;
			packet.message = message;
 
			return packet;
		}
 
 
		//---------------------------------------------------------------------------
		//
		// PUBLIC ACCESSORS
		//
		//---------------------------------------------------------------------------
 
		public function get command():uint { return _command; }
		public function set command(value:uint):void {
			_command = value;
		}
 
 
		public function get message():String { return _message; }
		public function set message(value:String):void {
			_message = value;
		}
	}
}

message FlashVar {
    required string key = 1;
    required string value = 2;
}

message LoginRequest {
    repeated FlashVar vars = 1;
}

message LoginResponse {
    ...
}

public class LoginHandler extends AbstractHandler<LoginRequest, LoginResponse>

protected LoginResponse handleImpl(LoginRequest message, DBProvider provider, User user)

register(LOGIN, new LoginHandler());

Код AS3:

	public class LoginHandler extends AbstractHandler
	{
		static public function sendMessage(message:LoginRequest, callback:Function):void
		{
			send(LoginHandler, message, callback);
		}
 
		override protected function get responseClass():Class
		{
			return LoginResponse;
		}
 
		override protected function handleImpl(m:Message):void
		{
			var message:LoginResponse = m as LoginResponse;

Код AS3:

register(LOGIN, new LoginHandler());

Код AS3:

			var message:LoginRequest = new LoginRequest();
			for (var key:String in _flashvars)
			{
				var flashVar:FlashVar = new FlashVar();
				flashVar.key = key;
				flashVar.value = _flashvars[key];
				message.vars.push(flashVar);
			}
			LoginHandler.sendMessage(message, login_callback);

Код AS3:

@Override
protected Object decode(ChannelHandlerContext context, Channel channel, ChannelBuffer channelBuffer, DecoderStates state) throws Exception {
	if (state == DecoderStates.LENGTH) {
		_length = channelBuffer.readInt();
		checkpoint(DecoderStates.TYPE);
	}
	else if (state == DecoderStates.TYPE) {
		_type = channelBuffer.readByte();
		checkpoint(DecoderStates.MESSAGE);
	}
	else if (state == DecoderStates.MESSAGE) {
		ChannelBuffer buffer = channelBuffer.readBytes(_length);
		checkpoint(DecoderStates.LENGTH);
 
		return PacketFactory.create(_length, _type, buffer.array());
	}
 
	return null;
}