Contrôle des intervalles temporels



Lorsque vous développez des applications à l'aide de Adobe Flash CS4 Professional, vous avez accès au scénario, qui fournit une progression constante, image par image, au sein de votre application. Toutefois, dans un projet purement ActionScript, vous devez compter sur d'autres mécanismes temporels.

Boucles ou minuteurs ?

Dans certains langages de programmation, vous devez mettre au point des motifs temporels à l'aide d'instructions en boucle telles que for ou do..while.

Les instructions en boucle s'exécutent en général aussi vite que la machine locale le permet, ce qui signifie que l'application sera plus rapide sur certaines machines que sur d'autres. Si votre application doit bénéficier d'un intervalle temporel cohérent, vous devez l'associer à un calendrier ou une horloge réels. Bien des applications, telles que les jeux, les animations, les contrôleurs en temps réel, nécessitent des mécanismes de décompte temporel qui soient cohérents d'une machine à l'autre.

La classe Timer d'ActionScript 3.0 offre une solution performante dans ce domaine. Grâce au modèle d'événements ActionScript 3.0, la classe Timer distribue des événements Timer dès qu'un intervalle spécifié est atteint.

La classe Timer

Pour la gestion des fonctions temporelles dans ActionScript 3.0, il est recommandé d'utiliser la classe Timer (flash.utils.Timer), qui permet de distribuer des événements dès qu'un intervalle est atteint.

Pour lancer un minuteur, vous devez d'abord créer une occurrence de la classe Timer et lui indiquer à quelle fréquence elle doit générer un événement Timer et combien de fois elle doit le faire avant de s'arrêter.

Par exemple, le code suivant crée une occurrence de Timer qui distribue un événement toutes les secondes pendant 60 secondes :

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

L'objet Timer distribue un objet TimerEvent chaque fois que l'intervalle donné est atteint. Le type d'événement de l'objet TimerEvent est timer (défini par la constante TimerEvent.TIMER). Un objet TimerEvent contient les mêmes propriétés que l'objet standard Event.

Si l'occurrence de Timer prévoit un nombre fixe d'intervalles, elle distribue également un événement timerComplete (défini par la constante TimerEvent.TIMER_COMPLETE) lorsqu'elle atteint l'intervalle final.

Voici un court exemple d'application illustrant la classe Timer en action :

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!"); 
        } 
    } 
}

Lorsque la classe ShortTimer est créée, elle génère une occurrence de Timer qui marque chaque seconde pendant cinq secondes. Elle ajoute alors deux écouteurs au minuteur : un qui écoute chaque décompte et un qui écoute l'événement timerComplete.

Elle lance ensuite le décompte du minuteur et à partir de là, la méthode onTick() s'exécute toutes les secondes.

La méthode onTick() affiche simplement le nombre actuel de tics. Après cinq secondes, la méthode onTimerComplete() s'exécute et vous avertit que le temps est écoulé.

Si vous exécutez cet exemple, vous devriez voir les lignes suivantes s'afficher dans votre console ou fenêtre de suivi à raison d'une ligne par seconde :

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

Fonctions temporelles du package flash.utils

ActionScript 3.0 contient un certain nombre de fonctions temporelles similaires à celles qui étaient disponibles dans ActionScript 2.0. Ces fonctions sont fournies au niveau du package dans le package flash.utils et elles fonctionnent de la même manière que dans ActionScript 2.0.

Fonction

Description

clearInterval(id:uint):void

Annule un appel de setInterval() spécifié.

clearTimeout(id:uint):void

Annule un appel de setTimeout() spécifié.

getTimer():int

Renvoie le nombre de millisecondes qui se sont écoulées depuis l'initialisation d'Adobe® Flash® Player ou d'Adobe® AIR™.

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

Exécute une fonction à fréquence définie (intervalle exprimé en millisecondes).

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

Exécute une fonction spécifiée après un délai spécifié (en millisecondes).

Ces fonctions demeurent dans ActionScript 3.0 afin d'assurer la compatibilité avec les versions antérieures. Adobe ne recommande pas leur utilisation dans les nouvelles applications ActionScript 3.0. Il est en général plus simple et plus efficace d'utiliser la classe Timer.