Décodage asynchrone des images bitmap

Flash Player 11 et les versions ultérieures, Adobe AIR 2.6 et les versions ultérieures

Lorsque vous manipulez des images bitmap, vous pouvez décoder et charger ces dernières en mode asynchrone pour optimiser les performances perçues d’une application. Dans de nombreux cas, le décodage asynchrone d’une image bitmap prend autant de temps que le décodage synchrone. L’image bitmap est toutefois décodée dans un thread distinct avant que l’objet Loader associé n’envoie l’événement COMPLETE. Il est par conséquent possible de décoder en mode asynchrone des images de taille supérieure après leur chargement.

La classe ImageDecodingPolicy du package flash.system permet de stipuler le modèle de chargement de bitmap. Le modèle de chargement par défaut est synchrone.

Traitement du décodage de bitmap

Modèle de chargement de bitmap

Description

ImageDecodingPolicy.ON_DEMAND

Synchrone

Les images chargées sont décodées lorsque l’utilisateur accède aux données de l’image.

Ce traitement est adapté au décodage des images de taille inférieure. Il s’avère également utile lorsque l’application ne nécessite pas d’effets et de transitions complexes.

ImageDecodingPolicy.ON_LOAD

Asynchrone

Les images chargées sont décodées au chargement, avant la distribution de l’événement COMPLETE.

Ce mode est parfaitement adapté aux images de taille supérieure (supérieure à 10 MP). Si vous développez une application mobile AIR contenant des transitions de page, faites appel à ce traitement de chargement de bitmap pour optimiser les performances perçues de l’application.

Remarque : si le fichier en cours de chargement est une image bitmap et que la méthode de décodage utilisée est ON_LOAD, l’image est décodée de façon asynchrone avant la distribution de l’événement COMPLETE.

Le code suivant illustre l’utilisation de la classe ImageDecodingPolicy :

var loaderContext:LoaderContext = new LoaderContext(); 
loaderContext.imageDecodingPolicy = ImageDecodingPolicy.ON_LOAD 
var loader:Loader = new Loader(); 
loader.load(new URLRequest("http://www.adobe.com/myimage.png"), loaderContext);

Vous pouvez continuer à utiliser le traitement de décodage ON_DEMAND avec les méthodes Loader.load() et Loader.loadBytes(). Néanmoins, toutes les autres méthodes qui prennent un objet LoaderContext comme argument ignorent toutes les valeurs ImageDecodingPolicy transmises.

L’exemple suivant illustre la différence entre une image décodée en mode synchrone et en mode asynchrone :

package 
{ 
    import flash.display.Loader;   
    import flash.display.Sprite;  
    import flash.events.Event; 
    import flash.net.URLRequest; 
    import flash.system.ImageDecodingPolicy; 
    import flash.system.LoaderContext; 
 
    public class AsyncTest extends Sprite 
    { 
        private var loaderContext:LoaderContext; 
        private var loader:Loader; 
        private var urlRequest:URLRequest;         
        public function AsyncTest() 
        { 
            //Load the image synchronously 
            loaderContext = new LoaderContext(); 
            //Default behavior. 
            loaderContext.imageDecodingPolicy = ImageDecodingPolicy.ON_DEMAND;             
            loader = new Loader();     
            loadImageSync();                     
             
            //Load the image asynchronously 
            loaderContext = new LoaderContext(); 
            loaderContext.imageDecodingPolicy = ImageDecodingPolicy.ON_LOAD;             
            loader = new Loader(); 
            loadImageASync();     
        } 
         
        private function loadImageASync():void{ 
            trace("Loading image asynchronously...");             
            urlRequest = new URLRequest("http://www.adobe.com/myimage.png");     
            urlRequest.useCache = false; 
            loader.load(urlRequest, loaderContext);                     
            loader.contentLoaderInfo.addEventListener 
                (Event.COMPLETE, onAsyncLoadComplete); 
        } 
         
        private function onAsyncLoadComplete(event:Event):void{             
            trace("Async. Image Load Complete"); 
        }     
     
        private function loadImageSync():void{             
            trace("Loading image synchronously...");             
            urlRequest = new URLRequest("http://www.adobe.com/myimage.png");     
            urlRequest.useCache = false; 
            loader.load(urlRequest, loaderContext); 
            loader.contentLoaderInfo.addEventListener 
                (Event.COMPLETE, onSyncLoadComplete); 
        } 
         
        private function onSyncLoadComplete(event:Event):void{             
            trace("Sync. Image Load Complete"); 
        } 
    } 
}

Pour une démonstration de l’effet des diverses stratégies de décodage, voir Thibaud Imbert: Asynchronous bitmap decoding in the Adobe Flash runtimes (disponible en anglais uniquement).