Home » Aportes »AS2 »Flash »POO »Referencia » Currently Reading:

Lo que yo sé de AS2 #Comunicación entre clases

marzo 18, 2007 Aportes, AS2, Flash, POO, Referencia 3 Comments
Lo que yo sé de AS2 #Comunicación entre clases

Lo que yo sé de AS2 (condensado y pasteurizado)

img*AUTOR: Juan Delgado Zárate
zarate.tv | dandolachapa.com | loqueyosede.com
FlashLa.com | After-Hours.org

Comunicación entre clases

>Indice de contenidos

Una de las partes más importantes y que más confusión y problemas ha generado de AS2 es la comunicación entre clases. Foros y listas de correo están llenos de problemas y dudas sobre “ámbitos”, “eventdispatchers” y “delegates”.

Como regla general yo diría:

  • Si necesitas comunicación dentro de la misma clase, siempre Delegate.
  • Si necesitas que más de una clase escuche lo que hace otra, siempre EventDispatcher.
  • Si la comunicación es 1:1, depende.

Vamos a ver el funcionamiento de los 2 métodos.

Delegate

NOTA: Lo que voy a contar aquí es prácticamente un copy&paste de un tuto que publiqué hace tiempo y que está enlazado al final. Si lo leíste en su día, te puedes saltar lo que sigue sin problemas.

Los foros de Flash están llenos de preguntas que tienen que ver con el “scope” o ámbito dentro de los famosos “callbacks” de objetos como XML, LoadVars, XMLSocket, etc. Flash necesita estas funciones porque las llamadas al servidor en Flash son asíncronas, es decir, el player no detiene la ejecución del código cuando se hace, por ejemplo, una petición de un fichero xml:

  1. classA{
  2.     private var oneVar:String="Helloworld";
  3.     functionA(){
  4.         varmyXML:XML = newXML();
  5.         myXML.ignoreWhite = true;
  6.         myXML.onLoad=function():Void{
  7.             trace(oneVar); //undefined ¬¬
  8.         }
  9.     myXML.load("myXML.xml");
  10.     }
  11. }

Esto pasa porque el ámbito “dentro” del onLoad es el propio objeto myXML, NO la clase. Puedes hacer la prueba haciendo trace(this) dentro del onLoad. Una de las primeras soluciones que se utilizó para esto fue crear dentro de la función principal una

variable que hacía referencia a la propia clase. Algo como esto:

  1. classA{
  2.     private var oneVar:String="Helloworld";
  3.     functionA(){
  4.         var owner=this;
  5.         var myXML:XML = newXML();
  6.         myXML.ignoreWhite = true;
  7.         myXML.onLoad = function():Void{
  8.             trace(owner.oneVar); //yeah!
  9.         }
  10.         myXML.load("myXML.xml");
  11.     }
  12. }

Y esto funciona. Este comportamiento “peculiar” de Flash (de los ECMAScript, vamos) se llama closure.

ámbito en las llamadas asíncronas. Pues a todo esto llegó la versión 7.2 del Flash IDE y el señor Mike Chambers introdujo la clase Delegate. Utilizando esa clase dejaríamos el código anterior en algo como esto:

  1. importmx.utils.Delegate;
  2. classA{
  3.     private var oneVar:String = "Hello world 2";
  4.     function A(){
  5.         var myXML:XML = new XML();
  6.         myXML.ignoreWhite = true;
  7.         myXML.onLoad = Delegate.create(this,xmlLoaded);
  8.             myXML.load("myXML.xml");
  9.         }
  10.     private function xmlLoaded(success:Boolean):Void{
  11.         trace(oneVar);
  12.     }
  13. }

Estamos “delegando” el onLoad en la función xmlLoaded, pero, lo más importante, el ámbito de la función xmlLoaded es la clase original, por lo que “encontramos” la variable sin problemas.

Esto definitivamente NO es lo mismo que hacer: myXML.onLoad = xmlLoaded. Si lo probáis, estaréis con el mismo problema que antes, el ámbito de la función xmlLoaded será el objeto myXML, por lo que el trace volverá a ser undefined.

El mayor problema de la clase de Macromedia (aún era Macromedia) es que NO permite el paso de parámetros a la función delegada, pero pronto llegaron los frikis para solucionarlo haciendo sus propias clases para delegar. La que yo utilizo es una copia con alguna modificación de una que encontré en la lista de MTASC. Con estas nuevas clases se pueden pasar parámetros de la siguiente forma:

  1. myXML.onLoad=Delegate.create(this,xmlLoaded,"val1",val2);

OJO, nuestros parámetros llegarán después de los “oficiales”, en este caso el típico success que llega a los onLoad del objeto XML.

EvenDispatcher

La misión básica de EvenDispatcher es permitir que varios objetos estén “escuchando” los eventos que lanza otro. EvenDispatcher siempre trata de comunicación entre clases, ya sea 1:1 (un emisor y un receptor) o 1:n (un emisor y varios receptores).

Técnicamente es una implementación del patrón Observer (ver enlaces al final) y fue introducida en su día por Macromedia. Pero como casi siempre apareció una versión libre, GDispatcher, en esta ocasión a cargo de Grant Skinner (gskinner.com).

Las clases que emiten eventos con EvenDispatcher son completamente independientes de quien esté escuchando, nunca saben si los escuchan 1 o 10, ellos sólo se limitan a emitir. Son como una radio o televisión con audiencia.

Sólo el objeto emisor necesita importar GDispatcher. Algo como lo siguiente:

  1. importcom.gskinner.GDispatcher;
  2. classbroadcaster{
  3.     public var addEventListener:Function;
  4.     public var removeEventListener:Function;
  5.     private var dispatchEvent:Function;
  6.     public function broadcaster(){
  7.         GDispatcher.initialize(this);
  8.         send();
  9.     }
  10.     private function send():Void{
  11.         var ev:Object = new Object();
  12.         ev.type = "myEvent";
  13.         ev.variable = "wadus";
  14.         dispatchEvent(ev);
  15.     }
  16. }
  1. import broadcaster;
  2. class receiver{
  3.     public function receiver(){
  4.         varbr:broadcaster = newbroadcaster();
  5.         br.addEventListener("myEvent",this,"callback");
  6.     }
  7.     private function callback(ev:Object):Void{
  8.         trace(ev.type+""+
  9.         ev.variable);
  10.     }
  11. }

Lo primero que llama la atención es que hayamos definido en la clase emisora unas variables del tipo Function. Si alguien se molesta en abrir GDispatcher puede ver que lo que hace en el método initialize es crear en tiempo de ejecución funciones a la clase que se le pasa como parámetro. Así que tenemos que definir esas mismas funciones como propiedades de nuestra clase para que el compilador no se queje de que el método al que el receptor trata de acceder (addEventListener) no existe.

La clase receptora es bastante simple. Simplemente importa a la emisora y se añade como listener para un evento concreto. Para hacerlo utiliza el método addEventListener pasando como parámetros el evento que quiere escuchar, el objeto que está escuchando (la propia clase (this) en este caso, pero se puede hacer que escuche otra) y la función que va a recibir la llamada. OJO que la función está pasada como cadena.

La implementación que hemos visto es perfectamente válida y funcional pero se puede mejorar. El primer problema es que el literal del nombre del evento (“myEvent”) lo estamos repitiendo dos veces, una en el emisor y otra en el receptor. Malo. Otra es que el tipo del parámetro que llega a la función receptora es del tipo genérico Object, lo que no nos permite ninguna validación de tipos al compilar. Malo también. Bueno, pues las 2 cosas las vamos a solucionar en la misma jugada. Vamos a crear un objeto específico para el evento y será ese objeto “conocido” el que se envíe.

  1. classmyEvent{
  2.     public static var EVENT_LITERAL:String = "eventOne";
  3.     public var type:String = "";
  4.     public var variable:Number;
  5.     public function myEvent(_variable:Number){
  6.         type = EVENT_LITERAL;
  7.         variable = _variable;
  8.     }
  9. }
  1. importcom.gskinner.GDispatcher;
  2. import myEvent;
  3. class broadcaster{
  4.     public var addEventListener:Function;
  5.     public var removeEventListener:Function;
  6.     private var dispatchEvent:Function;
  7.     public function broadcaster(){
  8.         GDispatcher.initialize(this);
  9.         send();
  10.     }
  11.     private function send():Void{
  12.         var ev:myEvent = new myEvent(5);
  13.         dispatchEvent(ev);
  14.     }
  15. }
  1. import broadcaster;
  2. import myEvent;
  3. class receiver{
  4.     public function receiver(){
  5.         var br:broadcaster = new broadcaster();
  6.         br.addEventListener(preventivamente_LITERAL,this, "callback");
  7.     }
  8.     private function callback(ev:myEvent):Void{
  9.         trace(ev.type + " "
  10.         + ev.variable);
  11.     }
  12. }

Mucho mejor. El literal con el nombre del evento sólo se define una vez en la clase myEvent. Se define como variable estática para que la clase receptora pueda utilizarlo sin tener que crear una instancia. La propiedad type se define para ser compatibles con EventDispatcher y GDispatcher.

Además con la nueva implementación el tipo del evento que llega al receptor es myEvent y no Object, por lo que tendremos validación de tipos al compilar.

Si sustituyes myEvent, por videoStarted, applicationReady, menuButtonPressed y similares, es cuando se empieza a ver la utilidad de EvenDispatcher (vamos, de un patrón Observer).

EvenDispatcher ¿vs? Delegate

Una vez vistos EventDispatcher y Delegate, ¿hay situaciones en las que se pueda elegir entre usar una opción o la otra? Ya hemos visto que la comunicación dentro de la misma clase siempre es con Delegate, así la decisión viene cuando hay que comunicar 2 clases. Vamos a ver cómo.

  1. importBroadcaster;
  2. importtv.zarate.utils.Delegate;
  3. class Receiver{
  4.     public function Receiver(){
  5.         var buttonCallback:Function = Delegate.create(this, buttonPressed);
  6.         var broadcaster:Broadcaster = newBroadcaster(buttonCallback);
  7.     }
  8.     private function buttonPressed():Void{
  9.         //este método se ejecuta cuando se presione el botón
  10.         //en la clase emisora
  11.     }
  12. }
  1. class Broadcaster{
  2.     public function Broadcaster(buttonPressedCallback:Function){
  3.         var button:MovieClip = base_mc.createEmptyMovieClip("button", 100);
  4.         button.onPress = buttonPressedCallback;
  5.     }
  6. }

Atención a la jugada. La clase receptora crea una función delegada y la pasa como parámetro a la emisora que simplemente se lo asigna al evento onPress de su botón. Así que cuando el botón es presionado, la clase emisora recibe sin problemas el evento.

Ahora, ¿qué hacemos si hay que pasar parámetros en la llamada? Esto es algo que NO podríamos hacer:

  1. button.onPress = buttonPressedCallback("parametro");

Ya que al añadir “()” estaríamos ejecutando la función. Si necesitamos pasar parámetros con este método, habría que pasar por una función intermedia. Repito sólo la clase emisora:

  1. importtv.zarate.utils.Delegate;
  2. class Broadcaster{
  3.     public function Broadcaster(externalCallback:Function){
  4.         var button:MovieClip = base_mc.createEmptyMovieClip("button", 100);
  5.         button.onPress = Delegate.create(this, butPressed, externalCallback);
  6.     }
  7.     private function butPressed(externalCallback:Function):Void{
  8.         externalCallback("parametro");
  9.     }
  10. }

Al utilizar la clase emisora internamente una función para recibir el evento onPress del botón, ya puede pasar los parámetros que quiera al callback externo.

[ anterior ] [ siguiente ]

img

Compártelo:

Lo que yo sé de AS2 #Comunicación entre clases
Visto 4.243 veces

Currently there are "3 comments" on this Article:

  1. chynasky dice:

    Hola, muy bueno el articulo. Pero por ejemplo en este ultimo caso. dices que al recibir el evento onPress del boton ya puede pasar los parámetros que quiera al callback.
    Como pasaría por ejemplo una referencia del botón presionado??

    otra pregunta.
    Pq usar EvenDispatcher / Delegate en vez de l patrón observer? aporta algún beneficio?

    gracias

  2. kassel dice:

    Despues de muxo pegarme con tu código Zarate, he llegado a una solucion que me gustaria plantaerte en el ejemplo básico de EvenDispatcher, que solo funciona si lo metes en un intercvalo, y despues de cmbiar el flujo de la programación, he cambiado la llamada a la funcion send(), dentro de la clase broadcaster, despues de crear el listener, no se si es la forma mas correcta pero he visto en la url:
    url
    que se hacia de esta manera y el flujo de la informacion es la correcta pues recibo el objeto ev, espero que esto ayude a alguien y si esta mal planteado tb espero recibir las criticas, cualqquier critica estoy aprendiendo.
    GRACIAS

Comment on this Article:








Twitter: zguillez

AdvertisementAdvertisementAdvertisementAdvertisement

Recibe las novedades por email



Map

Ranking

Codigoactionscript.org: 4.65 sobre 5 (106 valoraciones)

twitter-widget.com