AMFPHP Genie! es una herramienta que nos facilita mucho la vida para generar nuestros Value Objects o nuestras clases (para PHP y Flex) desde una Base de Datos MYSQL. Este interesante proyecto hace uso de asSQL 2.7 Beta que es un driver que nos ayuda a conectar directamente nuestras aplicaciones Flash/Flex con MySQL.

Actualmente se encuentra en su versión 0.2 y acorde al website vienen cosas interesantes para esta herramienta ademas del buen uso que le dan a las características de una app en AIR

Les recomiendo le hechen un vistazo y créanme si hacen uso de AMFPHP esta herramienta les facilitará enormemente la vida =)

Les dejo aquí unos screenshoots de la app en uso, la url del proyecto para su instalación.

http://dannykopping.co.za/amfphp-genie/

Saludos y Happy Coding!!!

Y por último que mejor que un extracto de las palabras de Luis Felipe para darle un poco más de sentido a estas palabras...
"La parte seria fue un poco más al sur, pueblos enteros desaparecidos y todavía incomunicados, si no fuera mucho con el terremoto de 8.8, el Tsunami terminó de barrer pueblos costeros que simplemente ya no están en el mapa. El problema de un país largo y flaco es que todo depende de una sola gran carretera que quedó cortada en varios tramos, por lo que el viaje al sur con ayuda es bastante difícil y accidentado."

En Flexeando encontraremos una seción llamada Pensamientos Flexeros muy al estilo Aral Balkan, una colección de recursos muy útiles e inclusive una recopilación del hashtag de twitter #filosofiaRIA.
Desde RIActive queremos desearle la mejor de las suertes a Flexeando y no olviden agregarlo a sus feeds y darle follow.

Requerimientos

Prerequisitos

Desarrollo

El escenario es el sig:

En las imágenes muestro como deberá quedar la biblioteca de los 3 swf que servirán como contenedores de los assets.
Únicamente coloqué dos elementos (Header, Footer), por motivos del ejemplo, y tienen asociada su clase respectiva desde la biblioteca.

No es necesario que pongamos contenido en el escenario ya que no mostraremos el swf cargado, solo utilizaremos sus elementos.

Vamos ahora a crear el fla que servirá como principal y desde donde pondremos unos controles para cargar los assets requeridos.

Colocamos 3 componentes en el escenario: Una etiqueta, un botón y un combo box. El botón y el combo box tienen como nombres de instancia "botonCarga" y "comboSeleccion" respectivamente.

El combo tiene los datos mostrados en la imagen colocados desde el Inspector de Componentes por motivos de facilidad en el ejemplo.

Los 3 componentes se encuentran dentro de un MovieClip que está en el escenario. Ese movie clip tiene de nombre de instancia "selector". Los componentes se encuentran dentro de este clip para después poder quitarlos más fácilmente.

Ese movie clip tiene el sig código en la línea de tiempo:

//ActionScript 3.0
 
comboSeleccion.addEventListener(Event.CHANGE, onComboChange);
botonCarga.addEventListener(MouseEvent.CLICK, onBotonClick);
 
botonCarga.enabled = false;
 
function onComboChange (event:Event):void 
{
	botonCarga.enabled = event.target.selectedIndex > 0;
}
function onBotonClick(event:MouseEvent):void
{
	MovieClip(parent).cargarAssets(comboSeleccion.selectedItem.data);
}

Como se darán cuenta la carga la hace una función llamada "cargarAssets" que se encuentra en la línea de tiempo principal, es decir, el "parent" de este clip. Ahora veamos el código que se encarga de la magia el cual se encuentra en la línea de tiempo principal:

import flash.utils.getDefinitionByName;
 
var req:URLRequest = new URLRequest();
var loader:Loader = new Loader();
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onAssetsComplete);
 
// Esta es la parte importante.
// El poner las clases cargadas dentro mismo contexto de la aplicación principal
var lc:LoaderContext = new LoaderContext();
lc.applicationDomain = ApplicationDomain.currentDomain;
 
// Esta fn se invoca desde el clip selector
function cargarAssets (seleccion:String):void 
{
	req.url = "assets/" + seleccion;
	loader.load(req, lc);// Pasándole como segundo argumento el contexto definido arriba
}
 
function onAssetsComplete (event:Event):void
{
	trace("Assets cargados y disponibles");
 
	// Definición de las clases a utilizar ( ya están disponibles )
	// Header y Footer están definidos en la biblioteca del swf cargado
	var Header:Class = getDefinitionByName("Header") as Class;
	var Footer:Class = getDefinitionByName("Footer") as Class;
 
	// Instancias de esas clases
	var _header:DisplayObject = new Header() as DisplayObject;
	var _footer:DisplayObject = new Footer() as DisplayObject;
 
	// Agregamos y acomodamos elementos
	addChild(_header);
	addChild(_footer); _footer.y = stage.stageHeight - _footer.height;
 
	// Ocultamos el componente de selección
	selector.visible = false;
}

El código muestra como carga un swf con la clase Loader. Hasta ahí todo normal. El punto importante es la instancia de "LoaderContext" que está definida justo antes de cargar los elementos y su propiedad applicationDomain. Esa instancia la utilizamos en la función load de la instancia de Loader.

var lc:LoaderContext = new LoaderContext();
lc.applicationDomain = ApplicationDomain.currentDomain;

Un ApplicationDomain es el contexto donde está disponible tu código. Normalmente se genera una instancia de ApplicationDomain por cada swf que tengamos pero con esa instrucción estamos indicando que las classes que contiene el swf de los assets queremos que esten disponibles en el mismo contexto que la película que lo carga, es decir, la película principal.

Una vez hecho eso, la clase la podemos utilizar como cualquier otra. En el ejemplo estoy obteniendo la definición de las clases "Header" y "Footer" en dos variables que después estoy instanciando y agregando al DisplayList para mostrarlas en la película principal.

El ejemplo supone que tiene una estructura de archivos similar a la sig:
- carpeta principal
  - main.swf
  - assets (carpeta)
    - assets_1.swf
    - assets_2.swf
    - assets_3.swf

Conclusión

Sabemos que existen las bibliotecas compartidas. Sabemos que podemos tener muchos elementos en la biblioteca y utilizar solo los requeridos pero, sin lugar a dudas, cuando debemos elegir entre varios elementos a cargar para una sola aplicación esta puede ser una de las mejores opciones. De esta forma no incrementan el tamaño de su aplicación principal teniendo assets en la biblioteca que podría no utilizar un usuario, ya sea por su rol asignado o por cualquier otra razón.

Esta técnica también les puede ayudar a actualizar las aplicaciones, al menos, en cuanto a los elementos gráficos mostrados debido a que con solo cambiar el/los swf de los assets podrán cambiar por completo el diseño de su aplicación.

Archivos

Aquí les dejo los archivos del ejemplo (Flash CS4):
- Carga_Assets.zip

Espero que les sirva este artículo para sus futuros proyectos.
Cualquier pregunta no duden en dejar un comentario en el post o enviarme un e-mail a: agonzalez@activ.com.mx

Si quieres un disco solo tienes que decirnos en los comentarios de este post que tecnología de la Plataforma Flash utilizas más y cuál es tu grupo de rock favorito, te contactaremos por mail para darte instrucciones de donde recoger tu premio.

Por cierto esta iniciativa salió de una charla entre Duane (@duanechaos), Sergio (@yacaFX) y Edgar (@edgarparada) la cual les compartimos también.

Esto no es algo nuevo, de hecho con cada nueva tecnología que sale al mercado (Silverlight, JavaFX, etc.) y/o cada que la W3C se pone las pilas sucede lo mismo, hay quiénes toman una posición a favor y hay quiénes toman una posición en contra; lo cuál es muy respetable siempre que esto vaya sustentado con argumentos y no simplemente como un factor de respuesta a todo el ruido que se genera en el medio.

La semana pasada tuve la oportunidad de participar con @freddier y @cvander en el programa de Mejorando la Web para hablar al respecto, y los comentarios que pude ver alrededor de esta discusión fueron bastante atinados. Es por eso que al final del programa decidí comentarle una inquietud a Freddy y a Christian (quiénes se mostraron entusiasmados) misma que comparto con ustedes en este post.

La idea es organizar un debate con 5 invitados de cada bando (por decirlo de una manera), es decir 5 entusiastas de Flash y 5 entusiastas de HTML 5. Ya tenemos algunas personas interesadas pero no creo que fuera en realidad algo muy democrático si no le diéramos cabida a cualquier persona de la comunidad que quiera participar.

Por lo que no importa que posición sea la tuya, si estás interesado en debatir queremos escuchar tu "elevator pitch" al respecto y si eres de los mejor articulados será un honor que lo compartas ese día con nosotros

Aún tenemos que definir las fechas pero tan pronto tengamos a los participantes lo haremos de manera formal, por lo que si estas interesado en participar no dudes en dejar tu comentario en este post lo antes posible.

pueden encontrar una lista completa de las nuevas características y funcionalidades en Adobe Labs.

En esta nueva versión, beta 2, las mejoras que se le hicieron las podemos dividir en tres secciones: impresión mejorada desde aplicaciones AIR, soporte mejorado en las comunicaciones por socket, mejoras en los TextInput y en el soporte para IME.

Lo requerido para comenzar a utilizar esta nueva versión y probarla es que descarguen el SDK de AIR 2 Beta 2, si utilizan Flash Builder o Flex Builder deben sustituir los archivos que se encuentran en la versión de SDK que utiliza de forma predeterminada Flex Builder.

Inicialmente, en la etiqueta principal del Application Descriptor hay que modificar la versión para la cuál compilan la aplicación y utilizar, ahora "2.0beta2" -> xmlns="http://ns.adobe.com/air/application/2.0beta2".

Si por alguna razón, las aplicaciones que hayan creado con la beta 1 de AIR 2 no se ejecutan en el runtime de AIR 2 beta 2, deberán recompilarlas ahora apuntando al beta 2.

Más adelante colocaremos algunas observaciones sobre esta nueva versión.

Recordemos que por la naturaleza de los SWF’s podemos comunicarlos sin importar si fueron generados vía Flex o Flash.

Como mínimo es necesario tener 2 swf para lograr esta comunicación y uno al menos debe fungir como mensajero (sender) y otro como escucha (listener) aunque ambos pueden realizar ambas tareas y es posible tener más de 2 swf en este proceso.

Algo que podría sonar atractivo si estamos trabajando en equipo y no todos usan AS3 es el hecho de que todos los objetos de tipo LocalConnection creados con cualquier versión de AS (1, 2 o 3) son compatibles.

Esta clase tiene dos métodos importantes para lograr la comunicación entre los SWF’s: send() y connect().

El método send() se encarga de enviar la petición de comunicación y requiere de 2 parámetros, el primero que será el nombre del canal y el segundo el método que se ejecutará en el swf destino. En caso de que el método destino requiera de parámetros estos deben de agregarse después del segundo parámetro y separado por comas.

El método connect() estará en el swf destino y recibirá como parámetro el nombre de la conexión que se estableció en el método send() en el swf origen. Con esto establecido el sfw destino ya estará habilitado para escuchar las peticiones a través de un LocalConnection.

Es importante que en el swf destino el objeto LocalConnection se le indique, a través de la propiedad “client”, en donde se encuentra el método que se está invocando desde el swf origen. Esto aplica si nuestro método está dentro de un paquete o en el mismo nivel donde se está instanciando el objeto LocalConnection. Otra consideración que se debe tener con este método es que debe ser declarado público.

Si al objeto LocalConnection destino no le indicamos la ubicación del método y este no lo declaramos como público la aplicación nos arrojará un error.

Ya entendida la funcionalidad de la clase y la lógica de este tipo de aplicaciones es hora de tirar algunas líneas de código y de probar esta funcionalidad.

Tendremos 3 archivos swf’s uno generado desde Flash y otro generado desde Flex y ambos tendrán los 2 roles necesarios para esta aplicación (Mensajero y Escucha) y el tercer SWF será generado desde Flash usando AS2 y solo con el rol de Escucha. Para efectos de este tutorial los tres SWF estarán integrados en el mismo archivo HTML.

Se me ocurre que esta aplicación sea algo similar a una calculadora donde en un primer SWF se ingresen 2 datos y se envíen al segundo SWF donde se elija la operación a realizar y regrese el resultado al primer SWF donde se le sumara una cantidad y el resultado final se enviará a un tercer SWF el cual solo mostrará este resultado final. Cada SWF tendrá un color de fondo distinto para poder identificarlos y están embebidos independientemente. El SWF1 es verde, el SWF2 es azul y el SWF3 es anaranjado

El código para el SWF1 hecho en Flash con AS3 queda así:

//Creamos el objeto tipo LocalConnection
var cnxLocal:LocalConnection = new LocalConnection();
 
enviarBtn.addEventListener(MouseEvent.CLICK, enviaDatos);
 
function enviaDatos(evt:MouseEvent):void
{
/*Enviamos datos a través del canal(conexión) 'cnxIda' 
indicándole que método ejecutar y los parametros a recibir*/
	cnxLocal.send('cnxIda', 'muestraDatos', dato1.text, dato2.text);
 
/*De una vez referenciamos la conexión o canal para 
recibir los datos de regreso que enviará la app en Flex*/
	cnxLocal.connect('cnxVuelta');
	cnxLocal.client = this;
};
 
/*Este método muestra el resultado calculado en el SWF2, 
hace un nuevo calculo y envía ese resultado al SWF3*/
function muestraResultadoRegresado(resultado:String):void
{
	resultado1.text = resultado;
 
	var resultadoFinal:String;
	resultadoFinal = String(Number(resultado)*10);
 
//Aquí es donde se envían los datos al SWF3
	cnxLocal.send('cnxFinal', 'muestraDatosFinales', resultadoFinal);
}

El código para el SWF2 hecho en Flex con AS3 queda así:

 import mx.controls.Alert;
 
//Creamos el objeto tipo LocalConnection
            private var _cnxLocal:LocalConnection = new LocalConnection();
 
            private function _initApp():void
            {
//Nos conectamos a la conexión definida en el SWF 1 para este SWF
                _cnxLocal.connect('cnxIda');
//Indicamos en donde esta el método invocado en SWF1
                _cnxLocal.client = this;
            }
 
//Este es el método invocado desde SWF1 y está definido como público
            public function muestraDatos(datoE1:String, datoE2:String):void
            {
                dato1.text = datoE1;
                dato2.text = datoE2;
            }
 
            private function _realizarCalculo(evt:MouseEvent):void
            {
                var resultado:Number;
                switch (evt.currentTarget.label)
                {
                    case '+':
                        resultado = Number(dato1.text) + Number(dato2.text);
                        break;
 
                    case '-':
                        resultado = Number(dato1.text) - Number(dato2.text);
                        break;
 
                    case '*':
                        resultado = Number(dato1.text) * Number(dato2.text);
                        break;
                    case '/':
                        resultado = Number(dato1.text) / Number(dato2.text);
                        break;
                }
                _regresaDatos(String(resultado));
            }
 
//Este método regresa el resultado al SWF1
            private function _regresaDatos(resultado:String):void
            {
                Alert.show(resultado, 'Resultado del calculo:');
                _cnxLocal.send('cnxVuelta', 'muestraResultadoRegresado', resultado);
            }

El código para el SWF3 hecho en Flash con AS2 queda así:

//Creamos el objeto tipo LocalConnection
var cnxLocal:LocalConnection = new LocalConnection();
 
//Nos conectamos a la conexión definida en el SWF 1 para este SWF
cnxLocal.connect('cnxFinal');
 
cnxLocal.muestraDatosFinales = function(resultado) {
 
//Se muestran en la caja de texto los datos recibidos
    resultadoFinal.text = resultado;
};

Como puede apreciarse la comunicación entre uno o varios SWF's es muy sencilla y en este tutorial queda sentado que no importa si es AS2 o AS3, Flash o Flex donde generemos nuestras aplicaciones, la comunicación a través de LocalConnection es transparente =)

Esperamos que este tutorial te sea de utilidad y si tienes dudas o comentarios no dudes en preguntarnos, ya sea a través de los comentarios o vía twitter en @riactive.

Sean felices y... Happy Coding!!!

Sergio Brito AKA yacafx

------------------------------------------------------------------------------------------------------
Los archivos fuente generados en este tutorial están disponibles para su descarga
[Source Files]

Para la elaboración de este post usamos Flash, Flex Builder, Photoshop y Balsamiq Mockups

Este tutorial está pensado para seguirse como receta de cocina y que en pocos pasos estén divirtiéndose trabajando con esta poderosa forma de conectar Flex con PHP.

Requisitos:

• Tener ZEND Framework en su última versión y completo. La razón de tenerlo completo radica en que cuando yo quise instalarlo y solo baje el paquete de ZEND_AMF me arrojaba constantemente errores de librerías requeridas. Para evitarnos eso vamos a conseguir toda la librería de Zend para no tener problemas. http://framework.zend.com/download/overview
• Un editor de texto plano o una IDE para PHP. http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo/SR1/eclipse-php-galileo-SR1-win32.zip
• Adobe Flex Builder 3. http://www.adobe.com/products/flex/
• Un servidor http que tenga el motor de ejecución PHP compatible con la versión de  Zend (Yo use wamp). http://www.wampserver.com/en/download.php

Contenido:

1. Organizar es buena idea: Preparando a Zend.
2. MiClasePHP.php: Creando una clase personalizada de PHP
3. El marco de la puerta: Creando a Zend_AMF_Server
4. La perilla de la puerta: Configurando Flex
5. Con quien voy a hablar?: RemoteObject y la configuraciones.
6. @Flex: “¿Donde estas @PHP?”. @PHP: “Aquiiiiii!!”

Introducción

Necesitas hacer llamada de una función que se encuentra en una clase PHP desde Flex y te preguntas ¿Cómo logro eso? Una de las diversas respuestas es: Zend_AMF

Zend_AMF es un paquete con el cual lograras hacer llamadas desde Flex a PHP. Zend es un framework para PHP muy potente, por lo tanto cuando el uso de los datos es extremo, esta es la mejor solución.

Preparando a Zend

Ok, ahora vamos con el primer paso operativo de esta receta.

En una carpeta del servidor http, colocaremos la carpeta llamada “Zend” la cual contendrá todo el framework que hemos bajado. Dentro del server colocaremos una carpeta que llamaremos “lib” la cual contendrá todas nuestras clases personalizadas.

Y por ultimo crearemos un archivo “zend_amf_server.php” que será el Zend_AMF_Server.

Creando una clase personalizada de PHP

Adentro de la carpeta “lib” crearemos una clase de PHP llamada “ClasePersonal” que tenga un método llamado “holaMundo” al cual se le pueda pasar un argumento de tipo string para ejecutar el ejemplo.

<?php
class ClasePersonal{
public function holaMundo($mensaje = 'Hi'){
$date = getdate();
return 'Hola desde PHP, Flex dijo: '. $mensaje .' el dia '. $date["seconds"];
}
}
?>

Como pueden observar es una clase cualquiera, no tiene alguna implementación especial o algo por el estilo.

Creando a Zend_AMF_Server

En lo personal ésta fue la parte más angustiante de todas, ya que por más que hacia copy-paste de código que obtenía en el sitio de Zend_AMF y de otros tutoriales que encontré, no salía correctamente y era porque a todos o les faltaba alguna línea u otros tenían una entrega del server distinta. La última línea de código de este PHP es la más importante de todas.

“zend_amf_server.php” será el equivalente a “gateway.php” que utiliza AMFPHP. Es la puerta de acceso al server de Zend_AMF.

Este será un pequeño archivo PHP que dará el acceso a Flex. En 6 puntos a seguir estará configurado.

Primero incluimos la librería Zend.

require_once 'Zend/Amf/Server.php';

Segundo incluimos a nuestra clase personalizada.

require_once 'lib/ClasePersonal.php';

Tercero instanciamos al Zend server.

$server = new Zend_Amf_Server();

Cuarto le enviamos a nuestro nuevo server la clase personalizada.

$server->setClass('ClasePersonal');

Quinto establecemos el método de entrega del server.

echo $server->handle();

Y como producto obtendremos un “zend_amf_server.php” con las siguientes líneas de código:

<?php
require_once 'Zend/Amf/Server.php';
require_once 'lib/ClasePersonal.php';
$server = new Zend_Amf_Server();
$server-&gt;setClass('ClasePersonal');
echo $server-&gt;handle();
?>

<mx:Nota>Sí tienen muchas clases de PHP y no tienen deseos de incluirlas al script de PHP y luego enviarlas a Zend. Pueden eliminar el segundo punto y además modifican el quinto por la siguiente línea de código antes del método de entrega del server.

$server->addDirectory('include/services/');

</mx:Nota>

Configurando a Flex

Para empezar debemos tener un proyecto de Flex abierto y crear un nuevo archivo con extensión XML adentro de la carpeta “src”.

Al siguiente archivo lo llamaremos “services-config.xml” (sin comillas) y será el encargado de decirle a Flex en donde se encuentra nuestro “zend_amf_server.php”

Este archivo es un documento en formato XML, dentro del cual colocaremos dos cosas importantes: La ruta del “zend_amf_server.php” y el nombre asignado a este canal.

En mi caso el XML contendrá lo siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<services-config>
<services>
<service id="zend-service" messageTypes="flex.messaging.messages.RemotingMessage">
<destination id="zend">
<channels>
<channel ref="zend-endpoint"/>
</channels>
<properties>
<source>*</source>
</properties>
</destination>
</service>
</services>
<channels>
<channel-definition id="zend-endpoint">
<endpoint uri="http://localhost/zend_amf_server.php"/>
</channel-definition>
</channels>
</services-config>

Como podrán ver, el XML tiene 2 puntos críticos que son los nodos “endpoint” y “destination” dentro de los cuales se especifica la ruta del zend_amf_server y el nombre que se le asignara para identificarlo dentro de Flex.

Una vez creado y guardado el XML nos vamos a nuestro proyecto y damos clic derecho>propiedades>Flex Compiler y en donde dice “Aditional compiler arguments” (Argumentos de compilación adicionales) le agregamos el texto  -services "services-config.xml" (con los guiones y las comillas) y aceptamos los cambios con el botón Ok.

RemoteObject y las configuraciones.

Ahora sí, le daremos un nombre a cada clase que necesitemos. Claro esto también se puede hacer en AS pero aquí les va el ejemplo en MXML.

Primero crearemos la etiqueta RemoteObject.

<mx:RemoteObject id="ClasePersonal" destination="zend" source="ClasePersonal" showBusyCursor="true" fault="onConexError(event)">

Aquí una pequeña lista de los atributos que necesitan y para qué sirven:

Id: El identificador con el que llamaran a la clase.

Source: El nombre de la clase PHP que vamos a llamar.

Fault: La función que arrojara para todos los métodos de esa clase, cuando exista algún error.

ShowBusyCursor: Es para que se muestre ocupado el mouse cuando está haciendo la llamada a los servicios PHP hasta que retorne algún valor/error.

Destination: Recuerdan que en el XML llamado “services-config.xml” tenía un nodo llamado destination, pues el valor del atributo de ese nodo es el que va aquí y sirve para indicarle a este RemoteObject a donde hay que enviar todas las consultas.

Una vez que ya colocamos la instancia de RemoteObject por clase PHP, pasaremos a indicar cuáles son los métodos de la clase PHP y como los llamaremos en Flex.

<mx:method name="holaMundo" result="onResultHolaMundo(event)"/>

Atributos de la etiqueta Methods:

Id: El nombre del método de la clase PHP.

Result: la función de Flex, la cual será llamada cuando exista regreso en un método de la clase PHP

Fault: Es la función de Flex que será llamada cuando exista un error de conexión en especifico para ese método de la clase PHP. Este atributo es opcional ya que en la etiqueta RemoteObject definimos una función de error para todos los métodos de esta clase.

<mx:Nota>Estos pasos se tendrán que repetir para cada método y para cada clase de PHP.</mx:Nota>

<mx:Nota>No olviden realmente definir las funciones en AS que son los resultados de las llamadas y las que son invocadas por errores.</mx:Nota>

Llamadas a las clases y los métodos.

Bueno, con esto se ha terminado todas las configuraciones. Ahora nos enfocaremos a terminar el tutorial, con un pequeño ejemplo.

A nuestra aplicación vamos a crearle una función de nombre “init” que estará disponible para el evento creationComplete de la aplicación, está se encargara de hacer la llamada al método de la clase PHP.

private function init():void{
ClasePersonal.holaMundo("Hola PHP");
}

Como nosotros ya definimos la función de AS que será la que responda nuestra llamada al método de la clase PHP, solo haremos que en un Label nuevo, le asigne el texto que nos regreso el método de PHP y después lo instanciaremos en el escenario de Flex.

private function onResultHolaMundo(event:ResultEvent):void{
var etiqueta:Label = new Label();
etiqueta.text = event.result.toString();
this.addChild(etiqueta);
}

Con esta parte estará completo nuestro MXML. Obteniendo así el script final.

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" creationComplete="init()">
<mx:Script>
<![CDATA[
import mx.controls.Alert;
import mx.rpc.events.ResultEvent;
import mx.controls.Label;
import mx.rpc.events.FaultEvent;
private function onConexError(event:FaultEvent):void{
<em>//Agregado para que arroje el error.</em>
Alert.show(event.fault.faultDetail, event.fault.faultString);
}
private function onResultHolaMundo(event:ResultEvent):void{
var etiqueta:Label = new Label();
etiqueta.text = event.result.toString();
this.addChild(etiqueta);
}
private function init():void{
ClasePersonal.holaMundo("Hola PHP");
}
]]>
</mx:Script>
<mx:RemoteObject id="ClasePersonal" destination="zend" source="ClasePersonal" showBusyCursor="true" fault="onConexError(event)">
<mx:method name="holaMundo" result="onResultHolaMundo(event)"/>
</mx:RemoteObject>
</mx:Application>

Comentarios y posibles problemas.

<mx:posibleproblema>Recuerden configurar su aplicación Flex como una aplicación de servidor PHP, ya que la seguridad de Flash Player no les permitirá acceder a un servidor http sino está corriendo bajo el mismo dominio, y si necesitan hacer llamadas entre dominios necesitaran un XML llamado “domain-config.xml” si lo requieren postéenlo y se los proporciono.</mx:posibleproblema>

<mx:comentario>Yo me he fijado que la primera vez que se hace llamada a algún método de nuestras clases, lo hace 2 veces y es porque en la primera establece la conexión y en la segunda ya hace la llamada. En la segunda llamada a algún método de la clase PHP ya no hará esto.</mx:comentario>

Asi les debe quedar la carpeta de su servidor al final. (Ahora ya tiene la version de depuracion de Flex porque lo creamos como una aplicacion de server PHP)

Lo demás lo pueden colocar con todo gusto y les apoyare con mi poca pero insistente experiencia xD

Hasta pronto, nos leemos en mi siguiente post. Byte.

Gracias a @eternalmoon_ por su participación en la corrección de este tutorial.

A primera vista podemos destacar una interfaz atractiva que no se parece a los clásicos portales tradicionales de banco, ya que Blink es un banco virtual que no tiene sucursales toda la actividad se realiza por internet, su lema dice “Don’t Bank, Blink!”

Flex para el Frontend

Si accedemos a la versión de prueba del servicio podremos jugar con la interfaz de usuario que muestra todas las posibilidades del banco virtual en un componente acordeón horizontal, seguramente de Flex Lib o desarrollado de manera interna porque recordemos que el acordeón nativo no tiene esa funcionalidad.

El manejo de los colores para sugerir la usabilidad de la aplicación es una de las características que salta a primera vista, en los grids hay diferentes tonalidades de acuerdo a la gama de colores seleccionados e inclusive es posible cambiar el color de toda la interfaz de acuerdo al estado de ánimo del usuario, un detalle bastante cool por cierto
En cuando a la experiencia de usuario podemos rescatar ciertas interacciones tipo drag&drop y algunos detalles de sensibilidad de acuerdo a la posición del cursor muy agradables. Hay algunos dashboards de la interfaz para revisar los índices de IPC, Dow Jones y NASDAQ, aunque en futuras versiones se agradecerían drill downs para hacer más dinámico el control de los datos.

Acceso a Datos

El acceso a datos en una aplicación que maneja muchas transacciones tiene que ser algo de lo más importante a considerarse y por el tipo de desempeño que vemos en Blink podríamos apostar nuestros 2 centavos a que están usando Remoting en alguna de sus variantes (Blaze, WebOrb, LCDS...)
Otro punto notable es que al cargar la aplicación, desde que se ejecuta podemos notar cierto bootstrapping de elementos comunes como iconografía y algunos estilos y controles, de otra manera no podríamos explicarnos su buen desempeño inclusive con anchos de banda algo limitados.
Queda el pendiente de revisar la aplicación con datos reales puesto que utilizamos la versión de prueba pero esperamos que se comporte igual de bien al momento de estar “transaccionando”.

Redes Sociales

Ninguna aplicación que se precie de ser 2.0 en este momento puede ignorar el poder de las redes sociales. En el caso de Blink ya están usando Twitter y Facebook, aunque hay que decirlo todavía a un nivel muy básico. Yo esperaría que en un futuro la integración fuera tal que inclusive cuando hicieras una transacción, el sevicio te mandara instantáneamente un DM por Twitter como alternativa al clásico SMS que utilizan la mayoría de bancas electrónicas.
Así mismo sería interesante que hubiera un apartado de wishlists de tus amigos en FaceBook que te permitiera rápidamente acceder a tiendas en línea a través del portal de Blink. En definitiva el target al cuál va orientado este servicio (estudiantes universitarios y recién egresados) poco a poco exigirá a sus desarrolladores mayor integración con Social Media y esperemos ver innovaciones interesantes al respecto.

Tecnologías Móviles

En este rubro Blink le apuesta a una buena estrategia abarcando las 3 plataformas de smartphones con más usuarios en este momento: iPhone, BlackBerry y Windows Mobile.
La aplicación de iPhone que fue la que tuvimos oportunidad de probar mantiene buenas críticas en la App Store y llega a ser un buen complemento a la aplicación de stocks original del dispositivo. Destaca también el que incluye un lector de RSS para mostrar las noticias financieras más relevantes así como los tipos de cambio del día.

Conclusiones

En definitiva Blink nos ha gustado mucho, hace tiempo que los portales financieros en México solamente se ocupaban del tema de seguridad y responsabilidad social, dejando muy olvidado el tema de experienciencia de usuario. Esperamos en un futuro ver más apuestas por Flex en proyectos en México que permitan ver las bondades de esta tecnología. Así mismo los invitamos a que nos dejen un comentario sobre su opinión al respecto.