Cairngorm: Secuenciado de Commands

En según qué ocasiones podemos requerir que nuestra aplicación ejecute una serie de Commands de forma asíncrona siguiendo un órden determinado.
Cairngorm viene de serie con la capacidad de encadenar Commands asíncronamente. La clase com.adobe.cairngorm.commands.SequenceCommand es la que se ocupa de que esto sea posible.
En esta entrada veremos dos formas de implementar el secuenciado. Una de forma estática y la otra de forma dinámica.


Encadenado estático

De forma nativa Cairngorm soporta encadenado estático de Commands, esto significa que para una secuencia dada deberemos crear una serie de Commands exclusiva para ésta.
El principal problema que se nos puede plantear en este caso es que si queremos reutilizar un Command que ya forma parte de una secuencia no podremos. Nos veremos forzados a duplicar código.
La causa de este problema viene del hecho que la clase SequenceCommand, la clase de la que extienden nuestros Commands a secuenciar, utiliza una propiedad nextEvent que es la que decide cuál es el siguiente Evento (y por consiguiente Command) que se va a ejecutar. La forma en la que los Commands son lanzados hace que sea imposible parametizar esta propiedad y por lo tanto se mantega estática.

Un ejemplo de un Command que forma parte de una secuencia:

HolaCommand.as (ejemplo estático)
[as]
package com.madeinflex.command
{
import com.adobe.cairngorm.commands.ICommand;
import com.adobe.cairngorm.commands.SequenceCommand;
import com.adobe.cairngorm.control.CairngormEvent;
import com.madeinflex.event.MundoEvent;
import mx.controls.Alert;
import mx.events.CloseEvent;
public class HolaCommand extends SequenceCommand implements ICommand
{
public function HolaCommand()
{
nextEvent = new MundoEvent( MundoEvent.MOSTRAR_MUNDO );
}
override public function execute( evt:CairngormEvent ):void
{
Alert.show( “Hola”, “HolaCommand”, Alert.OK, null, onClose );
}
private function onClose( evt:CloseEvent ):void
{
executeNextCommand();
}
}
}
[/as]

Encadenado dinámico

El encadenado dinámico es mucho más flexible que el estático dado que permite crear de forma dinámica las secuencias de Commands, de este modo podremos reutilizar un mismo Command para formar parte de diferentes secuencias o para ser lanzado individualmente.
Para conseguir este objetivo nos vamos a servir de una colaboración que Bjorn Schultheiss ha hecho al repositorio de recursos para Cairngorm: cairngormdocs.com.
Se trata de dos clases: com.bjorn.event.ChainEvent y com.bjorn.event.EventChainFactory.
La clase ChainEvent es un wrapper de com.adobe.cairngorm.control.CairngormEvent que añade la propiedad nextChainedEvent:ChainEvent, y la clase EventChainFactory es la que se ocupa de enlazar dinámicamente las diferentes instancias de eventos que queremos secuenciar. Se le pasa un Array de instancias de ChainEvent y va asignando de mayor a menor (en índice) cual es su nextEvent.

Un ejemplo de un Command que se añade dinámicamente a una secuencia, su evento relacionado y la forma de crear la secuencia:

HolaCommand.as (ejemplo dinámico)
[as]
package com.madeinflex.command
{
import com.adobe.cairngorm.commands.ICommand;
import com.adobe.cairngorm.commands.SequenceCommand;
import com.adobe.cairngorm.control.CairngormEvent;
import com.bjorn.event.ChainEvent;
import com.madeinflex.event.MundoEvent;
import mx.controls.Alert;
import mx.events.CloseEvent;
public class HolaCommand extends SequenceCommand implements ICommand
{
override public function execute( evt:CairngormEvent ):void
{
nextEvent = ChainEvent( evt ).nextChainedEvent;
Alert.show( “Hola”, “HolaCommand”, Alert.OK, null, onClose );
}
private function onClose( evt:CloseEvent ):void
{
executeNextCommand();
}
}
}
[/as]

HolaEvent.as (ejemplo dinámico)
[as]
package com.madeinflex.event
{
import com.bjorn.event.ChainEvent;
import flash.events.Event;
public class HolaEvent extends ChainEvent
{
public static const MOSTRAR_HOLA:String = “mostrar_hola”;
public function HolaEvent( type:String )
{
super( type );
}
override public function clone():Event
{
return new HolaEvent( type );
}
}
}
[/as]

Creación dinámico de la secuencia
[as]
//(…)
private function empezarSecuencia1():void
{
var evts:Array =
[
new HolaEvent( HolaEvent.MOSTRAR_HOLA ),
new MundoEvent( MundoEvent.MOSTRAR_MUNDO ),
new ExclamacionEvent( ExclamacionEvent.MOSTRAR_EXCLAMACION )
];
var chainEvent:ChainEvent = EventChainFactory.chainEvents( evts );
chainEvent.dispatch();
}
//(…)
[/as]

Proyectos de ejemplo

Incluyo dos proyectos muy simples de ejemplo. Uno para secuenciado estático y otro para secuenciado dinámico:

5 Comentarios

  1. theklue

    Creo que el secuenciado de eventos es uno de los problemas de “diseño” más típicos que te encuentras en un proyecto Cairngorm. Aunque se pueda resolver con el SequenceCommand, como muy bien dices, en ciertos casos repites muchisimo código. No conocía este sistema y sé que le voy a sacar mucho partido.

    Muchas gracias por la entrada y un saludo,

    Alberto

  2. Pingback: Flex+Cairngorm en castellano desde MIF : Joan Garnet

  3. rui

    Hi, Can you help me with implementation?

    I have this mainFunction on a file.as (not a class)

    ===============
    public function mainFunction():void {

    funtion1();

    funtion2();

    funtion3(); //execute some code on displayObjects
    funtion4(); //execute some code on displayObjects

    funtion5(); //execute some code on displayObjects

    }
    ==========================
    this kind of code frezze my app, and I’m trying to implement your aprouch… but the addCommand ask for Class, and I need to execute my function1 function2 function3 with access to my displayObjects…

    Can you sample me the addComand without Class? or the Class having access to my displayObjects?

    thanks,
    rui

  4. Joan Garnet

    Each of those functions could be an execute() method in a command class, you just have to refactor your code.
    Anyway, you can always chain your functions like this:

    function f1( nextFunction:Function ){
    //…..some logic here…..
    nextFunction.call();
    }
    f1( f2 );

    and so on…
    Cheers

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Acerca de Made In Flex

Made In Flex es una comunidad de desarrolladores de Apache Flex creada en 2006.

Apache Flex, anteriormente conocido como Adobe Flex, es un SDK (kit de desarrollo de software) para crear aplicaciones enriquecidas - multiplataforma basadas en Adobe Flash donado por Adobe a la fundación Apache in 2011 y promocionado a proyecto de primer nivel en Diciembre de 2012.

Actualmente estamos cambiando muchos aspectos del sitio web para ofrecer un sitio útil para toda la comunidad que tenga en cuenta las necesidades actuales.

Últimas Fotos

Instalador de Apache Flex

Entrar o Registrase