Controle de intervalos de tempo

Flash Player 9 e posterior, Adobe AIR 1.0 e posterior

Ao desenvolver aplicativos usando o Adobe Flash CS4 Professional, você tem acesso à linha do tempo, que oferece uma progressão uniforme quadro a quadro do seu aplicativo. No entanto, em projetos exclusivamente do ActionScript, é necessário usar outros mecanismos de controle de tempo.

Loops versus timers

Em algumas linguagens de programação, você deve desenvolver seus próprios esquemas de controle de tempo usando instruções de loop como for ou do..while.

As instruções de loop geralmente são executadas conforme permitido pela máquina local, ou seja, o aplicativo é executado mais rapidamente em algumas máquinas e mais lentamente em outras. Se o seu aplicativo precisa de um intervalo de tempo consistente, associe-o a um calendário ou relógio real. Muitos aplicativos, como jogos, animações e controladores em tempo real, precisam de mecanismos de tempo regulares que se adaptem a cada máquina.

A classe Timer do ActionScript 3.0 fornece uma solução incrível. Usando o modelo de eventos do ActionScript 3.0, a classe Timer envia eventos de tempo sempre que um intervalo especificado é atingido.

A classe Timer

O melhor modo de manipular funções de controle de tempo no ActionScript 3.0 é usar a classe Timer (flash.utils.Timer) para enviar eventos sempre que um intervalo for atingido.

Para iniciar um timer, você precisa criar primeiro uma ocorrência da classe Timer, informando com que frequência um evento de tempo deve ser gerado e quantas vezes isso deve ser feito antes de parar.

Por exemplo, o código a seguir cria uma ocorrência de Timer que envia um evento por segundo e continua durante 60 segundos:

var oneMinuteTimer:Timer = new Timer(1000, 60);

O objeto Timer envia um objeto TimerEvent sempre que o intervalo especificado é atingido. Um tipo de evento do objeto TimerEvent é timer (definido pela constante TimerEvent.TIMER ). Um objeto TimerEvent contém as mesmas propriedades de um objeto Event padrão.

Se a ocorrência de Timer for definida como um número fixo de intervalos, um evento timerComplete (definido pela constante TimerEvent.TIMER_COMPLETE ) também será enviado quando o intervalo final for atingido.

Veja um pequeno aplicativo de exemplo que mostra a classe Timer em ação:

package  
{ 
    import flash.display.Sprite; 
    import flash.events.TimerEvent; 
    import flash.utils.Timer; 
 
    public class ShortTimer extends Sprite 
    { 
        public function ShortTimer()  
        { 
            // creates a new five-second Timer 
            var minuteTimer:Timer = new Timer(1000, 5); 
             
            // designates listeners for the interval and completion events 
            minuteTimer.addEventListener(TimerEvent.TIMER, onTick); 
            minuteTimer.addEventListener(TimerEvent.TIMER_COMPLETE, onTimerComplete); 
             
            // starts the timer ticking 
            minuteTimer.start(); 
        } 
 
        public function onTick(event:TimerEvent):void  
        { 
            // displays the tick count so far 
            // The target of this event is the Timer instance itself. 
            trace("tick " + event.target.currentCount); 
        } 
 
        public function onTimerComplete(event:TimerEvent):void 
        { 
            trace("Time's Up!"); 
        } 
    } 
}

Ao ser criada, a classe ShortTimer cria uma ocorrência de Timer que será acionada uma vez por segundo durante cinco segundos. Em seguida, são adicionados dois ouvintes ao timer: um que ouve cada acionamento e outro que ouve o evento timerComplete .

Em seguida, começa o acionamento do timer e, a partir desse ponto, o método onTick() é executado em intervalos de um segundo.

O método onTick() simplesmente exibe a contagem de acionamentos atual. Depois de cinco segundos, o método onTimerComplete() é executado, informando que o tempo acabou.

Ao executar este exemplo, você deve ver as seguintes linhas na janela do console ou rastreamento, na velocidade de uma linha por segundo:

tick 1 
tick 2 
tick 3 
tick 4 
tick 5 
Time's Up!

Funções de controle de tempo do pacote flash.utils

O ActionScript 3.0 contém várias funções de controle de tempo similares às que estavam disponíveis no ActionScript 2.0. Essas funções são fornecidas no nível do pacote flash.utils e funcionam da mesma maneira como no ActionScript 2.0.

Função

Descrição

clearInterval(id:uint):void

Cancela uma chamada setInterval() especificada.

clearTimeout(id:uint):void

Cancela uma chamada setTimeout() especificada.

getTimer():int

Retorna o número de milissegundos desde que o Adobe® Flash® Player ou o Adobe® AIR™ foi inicializado.

setInterval(closure:Function, delay:Number, ... arguments):uint

Executa uma função em um intervalo especificado (em milissegundos).

setTimeout(closure:Function, delay:Number, ... arguments):uint

Executa uma função especificada após um atraso especificado (em milissegundos).

Essas funções estão incluídas no ActionScript 3.0 por questões de compatibilidade com versões anteriores. A Adobe não recomenda utilizá-las em novos aplicativos do ActionScript 3.0. Em geral, é mais fácil e mais eficiente usar a classe Timer em seus aplicativos.