Usamos cookies para medir audiência e melhorar sua experiência. Você pode aceitar ou recusar a qualquer momento. Veja sobre o iMasters.
E aí, galera! Sejam bem vindos!
Hoje eu quero mostrar para vocês algo chamado Nineveh Responder Engine, ou apenas NResponder. Para ser o mais claro possível, vou falar apenas sobre 4 tópicos, nada mais:
OK, vamos começar, então!
Nineveh o quê?
Nineveh é a forma em inglês para o nome Nínive. Ele é um novo Framework para AS3 que está em desenvolvimento. Ele é muito prático e direto, inspirado na lógica de programação C e Objective-C.
O Nineveh Framework é cheio de engines e APIs que funcionam de forma independente, assim eles podem funcionar perfeitamente mesmo fora do contexto do framework. E o Nineveh Responder é um desses engines.
OK, então que tipo de engine é o NResponder afinal? Uma Engine de Eventos!
Por muitos anos, eu usei a API nativa de Eventos do Flash framework, o famigerado EventDispatcher. Mais de 80% do framework nativo do Flash é herdado dessa "classezinha". Eu a acho muito chata e ruim, já que:
Bom, se você também não gosta do EventDispatcher, então NResponder é para você! Se você é completamente novo em Eventos no Flash e veio aqui para saber sobre Eventos, então NResponder é para você também!
NResponder é muito mais rápido que a API Nativa de Eventos do Flash. E uma das melhores coisas é que ele não precisa de instância nenhuma, se você não quiser. Ele consegue controlar e distribuir todos os eventos dentro de uma aplicação inteira.
Imagine que, em uma aplicação, você tem 3 botões no palco principal e carrega logo de início um outro SWF rodando um vídeo. Quando você pressionar um dos 3 botões, o vídeo que está tocando no outro SWF deve parar, porque um novo SWF será carregado por cima de tudo para apresentar um conteúdo.
Isso é bem similar ao comportamento de muitos sites.
Agora pense que, usando o EventDispatcher, você certamente teria que percorrer um longo caminho desde o clique no botão até finalmente para o vídeo e carregar o novo SWF.
Mas é aí que entra o NResponder. Tudo que você precisará com o NResponder são apenas duas linhas de código: uma no botão, outra no player do vídeo! Nada mais!
Veja, isso é apenas um comportamento natural do NResponder, porque ele não precisa utilizar instâncias. Você pode usá-lo para tudo relacionado a eventos, ações do mouse, eventos do teclado, eventos de multi-touch, tudo!
E assim como o título do artigo, você pode dizer definitivamente "adeus" ao EventDispatcher.
OK, agora você já sabe o que é NResponder. Você pode obter mais informações sobre ele na página do projeto no Google: http://code.google.com/p/nineveh-responder/ ou no meu blog, http://db-in.com/blog/nineveh-framework/nresponder/. Clique aqui para fazer o download dos fontes do NResponder: http://nineveh-responder.googlecode.com/files/Nineveh-Responder.zip
Obviamente você pode seguir a Wiki da página do projeto no Google ou ver a documentação completa do NResponder, mas aqui neste tutorial vou mostrar passo a passo como utilizar o grande poder do NResponder na sua aplicação.
Agora vamos em frente.
Características do NResponder
Antes de falar das características do NResponder, quero fazer uma comparação. Na tabela a seguir, você pode ver a API Nativa de Eventos do Flash (EventDispatcher e companhia) comparada com o NResponder.
FeatureEvent API (Adobe® Flash®)NResponder (Diney Bomfim)Used without instancenãosimUsed with instancesimsimSpecify number of dispatch argumentsnãosimDynamic dispatch argumentsnãosimChange dispatch arguments in Run-TimenãosimRemove allnãosimSpecify a delay timenãosimSet the number of repliesnãosimOrdenatesimsimCan associate with a targetsimsimCan pause without removenãosimCan stop propagationsimsimChange attributes in Run-TimenãosimGarbage Collectonly weak referencessimNeste artigo, vou focar nas características mais usadas.
O importante é saber que não há diferença entre os dois modos, ambos coexistem sem problemas, o que muda para você é que com o modo instanciado, você tem mais controle sobre o NResponder após criá-lo. Mas, em contrapartida, também se torna responsável por deletar aquela instância quando não precisar mais dela.
Por exemplo, quando deve ter:
eventDispatcherInstance.addEventListener("aCustomEvent", callBackFunction);
eventDispatcherInstance.dispatchEvent(new MyCustomEvent("aCustomEvent"));
...
private function callBackFunction(event:MyCustomEvent):void{
...
}Isso é muito chato! Porque se você quiser passar algum parâmetro para a função callBackFunc-tion(), neste caso, você precisa criar uma variavel dentro da sua classe de evento e ler essa variável dentro dessa função! Muito trabalho, né?
Com o NResponder, você pode se esquecer disso, já que é possível passar quantos parâmetros quiser diretamente para a sua função de retorno, e ela pode ficar deste jeito:
private function callBackFunction(aNumber:Number, aString:String, customOb-ject:ACustomObject):void
{
...
}Isso já dá a você muito mais flexibilidade para trabalhar! Imagine que agora você pode reutilizar essa função várias vezes, sem ter que passar um parâmetro null ou algo do tipo para um função que só aceita MyCustomEvent!
Veja, um exemplo muito comum é usado em classes de View (seguindo um modelo de MVC). Como você sabe, quando você inicia uma classe de View, ela pode não estar presente no palco, então sua propriedade de "stage" será nula. Para resolver isso, costuma-se usar a seguinte técnica:
public function Main()
{
if (this.stage)
{
init(null);
}
else
{
this.addEventListener(Event.ADDED_TO_STAGE, init);
}
}
public function init(){
if (this.hasEventListener(Event.ADDED_TO_STAGE))
{
this.removeEventListener(Event.ADDED_TO_STAGE, init);
}}Você precisa adicionar e remover, fazer checkagem com hasEventListener() para evitar erros, tudo para usar essa rotina uma única vez!
Já com NResponder, só o que você precisa fazer é especificar o número de respostas, nesse caso, para 1, nada mais. E ele também será o responsável, depois da última resposta que você definiu, por limpar toda a sujeira, remover o evento, deletar o que for preciso e ainda livrar memória da aplicação.
Por exemplo, você tem um botão no seu jogo que o usuário precisa clicar continuamente. Mas você não quer que ele clique como um louco no botão, você quer que, no mínimo, haja meio segundo entre dois cliques consecutivos. Com o NResponder, tudo que você precisa fazer é especificar esse número e pronto! O NResponder vai cuidar de todo o funcionamento dessa dinâmica para você.
Com o NResponder, você pode remover tudo de uma só vez, ou fazer remoções combinadas, como remover todos os registros relacionados a uma função de retorno, ou todos os registros relacionados a um alvo, ou mesmo remover todos os registros de um tipo de evento (ação na linguagem do NResponder), como Mouse.CLICK ou Keyboard.KEY_DOWN.
Não se preocupe se essa última parte não fez muito sentido agora, você vai entender mais claramente nos exemplos mais adiante.
OK, essas são as características mais importantes do NResponder. Eu não vou falar aqui sobre as características que possuem uma equivalente na API Nativa de Eventos, como ordenar e parar propagação, suponho que você já conheça essas características do velho EventDispatcher.
Mais uma coisa
Algo que alguns podem pensar até aqui é: "oK, você falou sobre MouseEvent, KeyboardEvent, TouchEvent, e disse que eu poderia dizer Adeus ao EventDispatcher, mas esses tipos de evento não são relacionados diretamente a API Nativa de Eventos, como é isso então?".
Yeah, você está certo!
Com o NResponder, você pode dizer Adeus ao EventDispatcher.
Mas, se você quiser, o NResponder fornece uma maneira de você trabalhar com os eventos nativos (apenas os eventos como o MouseEvent, KeyboardEvent, e todos os outros).
Obviamente que para trabalhar com esse tipo de evento, o NResponder precisa usar uma pequena parte da API Nativa de Eventos, porque no Flash é a única forma de se conseguir capturar esses eventos. Mas, novamente, NResponder pode fazer isso muito mais rápido e melhor que a API Nativa de Eventos.
Usos do NResponder
Mãos à obra!
Agora é bom que você tenha em mãos os arquivos fonte do NResponder, você pode baixá-los aqui.
Por enquanto, vamos apenas criar um projeto vazio onde teremos apenas alguns "prints" (trace) na tela. Você vai precisar de uma IDE para compilar e depurar o código, como Flash Professional, Flash Builder, Flash Develop, FDT etc.
OK, vamos codificar!
NResponder fica no caminho que começa no pacote "appkit" (um SubFramework do Nineveh Framework) e dentro deste, no pacote "responders". Esse caminho é apenas uma convenção de organização do Nineveh Framework.
package
{
import flash.display.MovieClip;
import appkit.responders.NResponder;
public class Main
{
public function Main():void
{
}
}}Agora, sobre o modo instanciado e estático. Toda vez que você criar um novo NResponder (registrar um evento, adicionar uma função de retorno, tanto faz, é tudo a mesma coisa para o NResponder), ele vai criar uma pequena e uma leve instância de "Responder"; essa instância vai para dentro do núcleo de processamento do NResponder e será ela a responsável por executar os comando dentro do motor do núcleo. Esse é o funcionamento do NResponder, ele sempre fará isso independentemente do modo que você estiver utilizando.
O legal aqui é que você pode ficar com uma copia dessa pequena instância quando você criar um novo NResponder. E você tem varias formas para pegar essa instância.
Importante: O código a seguir não é funcional, ele é apenas para ilustrar como usar os modos estáticos e instanciados. Na próxima seção (Criando um NResponder), você verá códigos mais funcionais.
package
{
import flash.display.MovieClip;
import appkit.responders.NResponder;
public class Main
{
public function Main():void
{
// This is the static mode
NResponder.add();
// This is the instantiated mode.
var responder:NResponder;
responder = new NResponder();
// Or even
responder = NResponder.add();
}
}}Você pode estar se perguntando: "espera, ok, só um minuto, que o construtor "new" crie uma instância tudo bem, mas por que uma chamada estática faria o mesmo?"
Bem, você entenderá isso logo, o construtor "new" é algo genérico, com ele você pode criar todo tipo de NResponder. Já os métodos "adds" (no plural porque tem mais de um add) têm alguns atalhos para que você não fique criando linhas muito longas de código. Como mencionei antes, o NResponder pode trabalhar com os eventos nativos do Flash, para isso ele tem um método "add" específico. Embora o construtor padrão "new" possa criar qualquer tipo de NResponder, você precisa passar mais parâmetros para ele.
Os modos instanciados e estáticos não impactam absolutamente em nada na performance e na memória da sua aplicação. A única razão para usar o modo instanciado é se você precisar alterar os parâmetros ou as características de uma instância de NResponder. Como, por exemplo, se você quiser pausá-lo sem removê-lo.
Mas se você não precisar alterar nada após criar um NResponder, não há motivos para ficar utilizando o modo instanciado.
Criando um NResponder
Agora vamos ver como definir uma função de retorno para um evento no Flash, ou de forma mais direta, vamos criar um NResponder!
É aqui que, além de apenas definir uma função de retorno, nós vamos especificar uma Ação (Ação para o NResponder é a mesma coisa que um Tipo para o EventDispatcher) e todos os outros tipos de atributos para o NResponder.
Importante: É aqui, nesta seção, que você já começa a dizer "adeus" ao EventDispatcher!
OK, a primeira coisa que eu quero mostrar é como você normalmente faz com EventDispatcher. Quando você precisa criar um evento personalizado (websites, por exemplo, tem dezenas desses), você faz algo como:
var myDispatcher:EventDispatcher;
myDispatcher.addEventListener('myCustomEventType', callBackFunction, false, 0, true);
...
myDispatcher.dispatchEvent(new CustomEvent('myCustomEventType'));[/as]
Isso é horrível! Porque o único jeito de você disparar seu CustomEvent é usando a instância do myDispatcher! E olhe como essa linha de myDispatcher.addEventListener é grande, completa-mente desnecessária.
Agora vamos transcrever isso para o NResponder, examente assim:
[as]
NResponder.add('myCustomEventType', callBackFunction);
...NResponder.dispatch('myCustomEventType'); Vamos falar sobre os disparos mais para frente; por agora, como você pode ver, não há necessidade de instância nenhuma e você nem precisa se preocupar com parâmetros adicionais como capture ou weak references, porque o NResponder não precisa desse tipo de coisa para trabalhar.
Aqui é importante lembrar o que é uma Ação para o NResponder. Como você viu, o 'myCusto-mEventType' é o Type para o EventDispatcher. Esse mesmo parâmetro é chamado de "Action" para o NResponder. Isso é apenas um detalhe, mas daqui em diante toda vez que me referir a Ação do NResponder, você saberá que estou falando do Tipo do Evento.
E, como vimos acima, você pode ficar com uma cópia da instância do NResponder:
var myReponder:NResponder = NResponder.add('myCustomEventType', callBackFunction);Lembre-se de que essa instância não interfere no funcionamento, ela apenas serve para você ter mais controle sobre o NResponder criado.
OK, agora vamos dar uma olhada em como é o NResponder trabalhando com a API Nativa de Eventos do Flash. O método para criar é muito similar ao "add" acima. Se você quiser criar um CLICK num botão com a API Nativa, por exemplo, você fará algo como:
var myButton:CustomButton;// probably inherited from MovieClip or Sprite.
myButton.addEventListener(MouseEvent.CLICK, clickFunction, false, 0, true);Com NResponder, fará:
var myButton:CustomButton;// probably inherited from MovieClip or Sprite.
NResponder.addNative(myButton, MouseEvent.CLICK, clickFunction);Simples assim!
Usar o método "addNative" é similar a usar o "add", apenas com uma única diferença: o primeiro parâmetro é o Alvo (Target) do evento nativo.
Algumas pessoas ficam confusas nessa parte. Mas tudo que você precisa lembrar é perguntar: "Quem é o responsável por disparar esse evento nativo? Quem é uma extensão da classe E-ventDispatcher?", então o objeto resultante dessa pergunta deverá ser passado no primeiro parâmetro do "addNative".
Desta forma:
/applications/core/interface/imageproxy/imageproxy.php?img=http://conteudo.imasters.com.br/19236/1.jpg&key=f1210a13adae21001fa20191d64f23430ee18d5a993cedf586b7b14ae9624c0d" alt="1.jpg" />
Você pode usar o NResponder com qualquer tipo de evento nativo. Os benefícios são que o NResponder irá trabalhar mais rápido, mais limpo e você ainda pode usar todas as características do NResponder. Os tópicos a seguir tratam a fundo dessas características.
Bom, como você pode já ter percebido, como uma boa prática em programação, para evitar erros de digitação no seu código, é aconselhável que você crie constantes públicas para armazenar as Ações que for usar com o NResponder, assim:
public static const CUSTOM_ACTION:String = 'myCustomAction';
...NResponder.add(CUSTOM_ACTION, callBackFunction);Bem, essa é apenas uma dica, embora neste artigo apenas para ser mais direto eu vou usar Strings literais em vez de constantes.
Tudo que você precisa é informar a Ação que você quer disparar e os parâmetros que você quiser, isto é, se precisar de parâmetros.
Assim:
// This will dispatch "myAction" with no arguments. So the callBack function don't need to ex-pect any parameter.
NResponder.dispatch('myAction');
// This will dispatch "anotherAction" with the arguments 35 (Number) and "aString" (String)
// So the callBack function should expect these parameter (Number and String in this order).
NResponder.dispatch('anotherAction', [35.5, 'aString']);O método dispatch() é simples, ele vai disparar a Ação informada para toda a aplicação, assim qualquer funcão que esteja preparado para receber essa Ação irá fazê-lo.
OK, então talvez você possa se perguntar "se o NResponder irá disparar a Ação para qualquer um na aplicação, o que acontecerá então com os botões, por exemplo? O clique será disparado para TODOS? Como é que o NResponder vai saber para quem disparar?"
Ótimo ponto!
A resposta é: usando o parâmetro Alvo (Target)!
Você lembra, no método addNative(), que você especificou um Alvo (Target)? É aqui que ele faz toda a diferença. Se você especificar um Alvo ao criar um NResponder, esse Alvo irá funcionar como uma "trava" e esse NResponder só vai responder quando essa "trava" for especificada.
Bem, isso pode parecer um pouco confuso falando assim por cima, mas apenas pense que o NResponderCore irá cuidar disso para você. Se você estiver usando eventos nativos como MouseEvent, KeyboardEvent ou qualquer outro, isso irá acontecer automaticamente durante os disparos. Apenas informe o Alvo correto e não se preocupe mais com isso.
Você pode utilizar o Alvo mesmo sem ser um evento nativo. Assim você pode tirar proveito dessa "trava" que ele te proporciona. Mas este é um tópico avançado do NResponder e eu não vou falar disso aqui para não te confundir. Se você quiser saber mais sobre isso, veja a Wiki do projeto.
Vamos em frente.
Com o número de respostas, você pode especificar quantas vezes um NResponder vai responder antes de ser automaticamente removido e limpo. E só o que você precisa fazer é especificar o número que desejar logo após o parâmetro "listener" dentro dos métodos "adds". Assim:
NResponder.add('myCustomEventType', callBackFunction, 5);
NResponder.addNative(myButton, MouseEvent.CLICK, clickButton, 2);NResponder.addNative(this, Event.ADDED_TO_STAGE, init, 1);No código acima:
Você pode especificar qualquer número inteiro e não negativo. E, apenas por convenção, o valor 0 (padrão) significa que o NResponder vai acontecer infinitamente, obviamente porque um NResponder não pode ser criado para responder 0 vezes.
Imagine que você tem um botão em seu jogo e não quer que o usuário clique no botão igual um louco. Você pode querer que o usuário só possa clicar no botão a cada 2.5 segundos. Bem, tudo que você precisa fazer então é especificar o próximo parâmetro depois do número de respostas no métodos "adds".
NResponder.addNative(myButton, MouseEvent.CLICK, clickButton, 0, 2.5);Isso significa que a funcão "clickButton" só poderá acontecer novamente depois de 2.5 segundos. Se o usuário fizer um clique e depois clicar novamente antes de 2.5 segundos, esse segundo clique será ignorado.
O valor pardão é 0 e significa nenhum intervalo de tempo.
Vamos começar com um caso simples, você quer saber se existe na sua aplicação algum registro para a Ação "myAction", então:
NResponder.has('myAction');Simples assim!
O exemplo acima trará um retorno no valor Boolean "true" se houver ao menos um único registro com a Ação "myAction".
Agora imagine que você quer saber se há algum registro da Ação "myAction" ligada a uma função de retorno específica.
NResponder.has('myAction', myFunction);Isso irá retornar "true" se houver na aplicação ao menos um registro com a Ação "myAction" e a função de retorno "myFunction".
E, por último, vamos checar se há o exemplo acima possui um Alvo (Target) atrelado a ele.
NResponder.has('myAction', myFunction, myTarget);Este irá retornar "true" se houver na aplicação ao menos um registro de NResponder com a Ação "myAction", ligada a uma função "myFunction" e um Alvo "myTarget".
A parte boa aqui é que você pode combinar esses 3 parâmetros, desta maneira:
NResponder.has('myAction', null, myTarget);
NResponder.has(null, myFunction, myTarget);
NResponder.has(null, myFunction, null);NResponder.has(null, null, myTarget);As quatro linhas acima significam:
O null nas funções do NResponder significa que você deseja ignorar o parâmetro e se focar nos outros. Essas combinações são especialmente úteis quando você não tem mais acesso a um ou dois parametros relacionados.
Mas o mais útil das combinações é quando você as utiliza para remover. Você pode remover vários NResponders de uma só vez com uma única linha de código.
O método remove() trabalha exatamente como o método has():
NResponder.remove(null, null, myTarget);A linha acima significa que você vai remover todos os NResponders que esteja relacionados ao Alvo "myTarget".
Agora pense em um botão com Dragging. Você pode registrar vários NResponders nele, um para o MOUSE_OVER, um para o MOUSE_OUT, MOUSE_DOWN, MOUSE_UP e MOUSE_MOVE.
Bem, são 5 NResponder. E se você precisar remover todos, pode fazer isso em uma única linha. Assim:
NResponder.addNative(myButton, MouseEvent.MOUSE_OVER, overFunction);
NResponder.addNative(myButton, MouseEvent.MOUSE_OUT, outFunction);
NResponder.addNative(myButton, MouseEvent.MOUSE_DOWN, startDragFunction);
NResponder.addNative(myButton, MouseEvent.MOUSE_UP, stopDragFunction);
NResponder.addNative(myButton, MouseEvent.MOUSE_MOVE, draggingFunction);
...NResponder.remove(null, null, myButton);Lembre-se de que o núcleo do NResponder é responsável por limpar tudo, e ele vai saber exatamente como e onde fazer isso com apenas esta única linha de código com a função remove().
Não vou falar aqui sobre todos esses benefícios, como eles são de utilização mais avançada, você pode ler sobre eles na Wiki do Projeto no Google e na documentação oficial.
Bom, vou falar então sobre um benefício específico chamado "pausado" (paused). Essa propriedade possui um valor booleano, no qual "true" indica que o NResponder está pausado.
Claro, como o nome sugere, você pode parar temporariamente o funcionamento de um NResponder sem precisar removê-lo. Isso é muito útil quando você precisa interromper um NResponder por um curto tempo.
Por exemplo, imagine que na sua aplicação há uma interface 3D que reage à posição do mouse na tela. Mas se o usuário pressionar a barra de espaço aparecerá sobre a tela uma espécie de "pop-up" e durante o tempo que o usuário permanecer neste "pop-up" você quer que a inter-face 3D pare de reagir com à posição do mouse.
Bem, tudo que você precisa é usar a propriedade "pausado". Desta maneira:
var myResponder:NResponder = NResponder.addNative(my3DInterface, MouseE-vent.MOUSE_MOVE, interactFunction);
...// When start the pop-up, use this to pause this NResponder.
myResponder.paused = true;
...// When close the pop-up, use this to reactivate this NResponder again.
myResponder.paused = false;Obviamente você também poderia remover e adicionar o NResponder novamente usando o modo estático, mas utilizando essa propriedade "pausado", você economiza muito processamento do CPU e salva muita memória da sua aplicação. Além de ser mais rápido também.
Muito bem, aqui eu apresentei algumas características do NResponder, as mais úteis e importantes. Lembre-se de conferir a página do projeto para ver tudo que não foi dito aqui sobre o NResponder.
Por hora, isso é tudo que precisamos saber para dizer "Adeus EventDispatcher". Com o que vimos até aqui, é possível utilizar quase tudo do NResponder.
Na próxima parte destes artigos, veremos uma utilização real do NResponder para solucionar problemas complexos de forma simples no nosso dia-a-dia de programação.
http://imasters.com.br/artigo/19236/cms/diga-adeus-ao-eventdispatcher-e-ola-ao-nresponder-parte-01
Carregando comentários...