Nunca, por ninguna razón hagas click en este link y mucho menos si eres menor de edad

Leo en Adobe Labs que el beta del Flash Player 10 ya está disponible.

Entre las mejoras que dicen que tienen son:

Crear tus propios Filtros y Efectos
Efectos 3D
Nuevo Motor de Texto (Empiezo a pensar que en esto se basa adobe para llamar a una versión nueva versión)
Rendereo Gráfico por Hardware
Clase Vector
Streaming Dinámico
RTMFP (Si ya había sockets binarios no entiendo la intruducción de esto)
Speex Audio Codec
Generación dinámica de sonidos (Empezaremos a ver instrumentos virtuales por toda la web)
Soporte de Bitmaps más pesados
GB18030 (Porque a los Chinos no se les puede ignorar)
Ubuntu OS (Un poco más y ya no tendré que usar más Windows excepto para desarrollar xna para xbox)

Lamentablemente en el player 9 todavía hay muchas cosas por corregir. En realidad es un poco ofensivo que sólo por motivos mercadológicos estén liberando esta versión en lugar de ponerse a trabajar en los bugs graves reportados del player 9; sólo cuando un bug hace mucho ruido, es publicado por alguna empresa de seguridad o hay periodicazos al respecto es cuando los corrigen. Y es muy probable que estos bugs los herede la nueva versión.


A continuación algunos de los bugs conocidos del Flash Player 9:

• Inaccesibilidad a elementos gráficos en fotogramas diferentes de 1 en películas cargadas externamente. Esto hace que el player se cierre abruptamente sin avisar siquiera.
• Incapacidad de clonar objetos utilizando Clase.constructor() en Adobe AIR
• Cuando cambian de tamaño los elementos gráficos de un objeto que está anidado no se cambia la propiedad width y height, hay que recurrir a un contenedor.

Espero que la gente de Adobe no conteste como alguna vez lo hizo Collin Mock en un foro de flash 7 en donde le pedían poder utilizar control de versiones con AS a lo cual respondió: No imagino que exista un proyecto tan grande que pueda necesitar eso y no imagino que podría ser

El comentario, por supuesto ya no existe, ni el foro, ni el jueguito de pingüinos saltando de un trampolín del cual se sentía tan orgulloso Mock (para esta época ya existía el mundo virtual de coca-cola y un par de proyectos más que utilizaban actionscript en grandes cantidades con equipos igual de grandes)

Ahí los dejo a su consideración. ¿Será el proyecto Astro® una charada?¿Corregirán los bugs que nunca corrigen?¿En realidad funcionará el rendereo por hardware completo?¿Seguirán pensando que MXML es la mejor idea que han tendio?

¿Qué pasaría si nintendo hiciera Halo®?

Aquí un ejemplo:

Me encanta el rollo de las princesas y los héroes de Nintendo

De las preguntas que más me hacen es como conectar un socket con actionscript. El problema generalmente es que muchos tienen el código correcto para conectarse en ActionScript pero no lo tienen del lado del servidor. Aquí pongo un ejemplo sencillo, 2 proyectos para eclipse uno en Java que es una versión sencilla de un servidor que crea un socket en el puerto 9999 y el otro proyecto en ActionScript para conectarse a este socket.

Lo primero que necesitamos es tener el eclipse instalado así como el plugin de flex para eclipse.

Una vez hecho esto creamos 2 proyectos un proyecto Java que llamaremos QuantiumBinaryConnectionToFlashPlayerBuildedInFlexSocket.

Creamos una clase llamada simpleServer que va a ser nuestra clase principal, osea donde va a estar nuestro método main.

Por la simplicidad de este ejemplo no vamos a hacer un socket complejo, de hecho sólo escribiremos unas cuantas líneas de código en la función main.

Empezamos creando una variable de tipo char que representará el End Of Line de nuestos mensajes, esto es porque es el caracter que le indica al player que el mensaje ha terminado:

[ftf]
char EOF = (char)0×00;
[/ftf]

Después, en nuestra funcion main abrimos un try en donde correrá nuestro socket, utilizando las clases ServerSocket y Socket y abriendo una conexión en el puerto 9999, tomando el catch para saber que la sesión ha terminado:

[ftf]
try
{
// create a serverSocket connection on port 9999
ServerSocket s = new ServerSocket(9999);
String msgstr = “”;

System.out.println(”Servidor iniciado. Esperando conexión del cliente…”);
// wait for incoming connections
Socket incoming = s.accept();

BufferedReader data_in = new BufferedReader(
new InputStreamReader(incoming.getInputStream()));
PrintWriter data_out = new PrintWriter(incoming.getOutputStream());
}
catch (Exception e)
{
System.out.println(”Conexión terminada”);
}
[/ftf]

Una vez creada nuestra conección, creamos un blucle que estará verificando si se recibe algún mensaje, y en caso de que la conexión termine se rompa el bucle:

[ftf]
boolean quit = false;

while (!quit)
{
String msg = data_in.readLine();

if (msg == null) quit = true;
}

[/ftf]

Finalmente agregamos un pequeño condicional que verificará si el mensaje enviado es salir y en caso de que lo sea termina el bucle, terminando así la ejecución del programa; y en caso contrario que regrese el mismo mensaje que ha sido recibido:

[ftf]
if (msg.trim().equals(”salir”))
{
data_out.println(”Adios”+EOF);
data_out.flush();
quit = true;

}
else
{
data_out.println(msgstr+EOF);
data_out.flush();
}
[/ftf]

Esto es todo lo que necesitamos hacer para tener nuestro servidor local para probar nuestro socket.

Ahora vamos con ActionScript.

Creamos un proyecto Flex AIR® que llamaré por puro gusto egocentrista QChat. En nuestro asqueroso MXML agregamos un TextArea, un TextInput y un Button.

Luego creamos la clase que se conectará a nuestro servidor llamada ChatSocket. Dicha clase será hija de la clase Socket.

Creamos una variable de tipo string a la cual llamaremos response que guardará toda la historia de mensajes recibidos.

[ftf]

private var response:String;

[/ftf]

En el constructor de nuestra clase vamos a inicializar al constructor del padre y llamar a la función según la escuela de los evangelistas de adobe que inicializa los lísteners de nuestro socket.

[ftf]
public function ChatSocket(host:String=null, port:int=0)
{
super(host, port);
configureListeners();
}
private function configureListeners():void
{
addEventListener(Event.CLOSE, closeHandler);
addEventListener(Event.CONNECT, connectHandler);
addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
}

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

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

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

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

private function socketDataHandler(event:ProgressEvent):void
{
trace(”socketDataHandler: ” + event);
}

[/ftf]

Hasta aquí vamos bien, si no has entendido nada pulsa Alt+F4.

Ahora crearemos una Clase que nos servirá como utilidad ortogonal para nuestro proyecto. Osease que vamos a crear un hijo de la clase Event que se llamará ChatSocketEvent. Este tipo de eventos por el momento sólo serán despachados al momento de recibir un mensaje.

[ftf]
public static const RESPONSE:String = “response”;

protected var _message:String;
public function get message():String
{
return _message;
}
public function ChatSocketEvent($type:String, $message:String, $bubbles:Boolean=false, $cancelable:Boolean=false)
{
_message = $message;
super($type, $bubbles, $cancelable);
}
[/ftf]

Una vez creado nuestro evento vamos a utilizarlo para enviar el mensaje recibido en la función socketDataHandler en nuestra Clase ChatSocket.

[ftf]
private function socketDataHandler(event:ProgressEvent):void
{
var str:String = readUTFBytes(bytesAvailable);
dispatchEvent(new ChatSocketEvent(ChatSocketEvent.RESPONSE,str));
response += str;
}
[/ftf]

Ahora que ya leemos la respuesta del servidor vamos a hacer un método que se encargue de enviar datos llamado say, en este método escribimos los bytes en modo UTF en el socket y hacemos flush, todo esto dentro de un try para cachar cualquier error:

[ftf]
public function say($message:String):void
{
response = “”;
$message += “\n”;
try {
writeUTFBytes($message);
}
catch(e:IOError) {
trace(e);
}
flush();
}

[/ftf]

Ahora regresemos a nuestro horroroso MXML.

Creamos la variable _localSocket que será una instancia de nuestra clase ChatSocket

[ftf]
private var _localSocket:ChatSocket = new ChatSocket();
[/ftf]

Vamos agregar un método que escuche el evento de inicialización de nuestro AIR, en el cual inicializaremos el socket y agregaremos el evento que escuchará al teclado para que en el momento de presionar enter se envíen los mensajes, dentro del evento ponemos:

[ftf]
_localSocket.addEventListener(ChatSocketEvent.RESPONSE, serverResponse);
_localSocket.connect(”localhost”, 9999);
addEventListener(KeyboardEvent.KEY_DOWN, keyDown);
[/ftf]

Como podemos ver hemos creado dos métodos: serverResponse y keyDown. serverResponse escucha los eventos tirados por nuestro socket y los envía a nuestro TextArea y keyDown escucha cuando el usuario presiona enter y envía el mensaje viva la usabilidad.

[ftf]
protected function serverResponse($evt:ChatSocketEvent):void
{
console.text += “Server :: “+$evt.message+”\n”;
}
protected function keyDown($evt:KeyboardEvent):void
{
if($evt.keyCode == Keyboard.ENTER)
{
sendChat();
}
}

[/ftf]

El evento sendChat que es llamado al presionar ENTER también será llamado al presionar el botón que tenemos en nuestro purulento MXML.

[ftf]
public function sendChat():void
{
_localSocket.say(input.text);
console.text += “Quantium :: “+input.text+”\n”;
input.text = “”;
}
[/ftf]

Para hacer las llamadas desde nuestro componentes hacemos algo como esto:

<mx:TextArea id="console" width="100%" height="100%"/>
<mx:TextInput id="input" width="85%"/>
<mx:Button id="send" label="Button" width="10%" textAlign="center" click="sendChat()"/>

Y listo, ya está nuestro pequeño Chat. Para probar su funcionamiento puedes descargar o ejecutar el archivo .jar aquí.

Y para descargar la aplicación AIR lo puedes hacer aquí abajo:

Importante: El air no funcionará si el jar no está ya corriendo cuando se ejecute. Primero ejecuta el archivo simpleServer.jar y después el air.

¿Te gustaría tener los archivos fuente de este ejemplo completos y listos para correrse desde eclipse?
¡¡¡Adquiere los Archivos de este tutorial!!

solo 5 dólares