Décodage asynchrone des images bitmap

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.

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).

Les publications Twitter™ et Facebook ne sont pas couvertes par les dispositions Creative Commons.