Decodifica asincrona delle immagini bitmap

Flash Player 11 e versioni successive, Adobe AIR 2.6 e versioni successive

Quando utilizzate immagini bitmap, potete decodificarle e caricarle in maniera asincrona per migliorare le prestazioni apparenti dell'applicazione. Il tempo richiesto per decodificare un'immagine bitmap in maniera asincrona potrebbe essere identico, in molti casi, a quello richiesto per la decodifica sincrona della stessa immagine. Tuttavia, la decodifica dell'immagine bitmap viene eseguita in un thread separato prima che l'oggetto Loader associato invii l'evento COMPLETE . Pertanto, potete decodificare in maniera asincrona immagini più grandi dopo averle caricate.

La classe ImageDecodingPolicy nel pacchetto flash.system consente di specificare lo schema di caricamento bitmap. Lo schema di caricamento predefinito è sincrono.

Criterio decodifica bitmap

Schema di caricamento bitmap

Descrizione

ImageDecodingPolicy.ON_DEMAND

Sincrono

Le immagini caricate vengono decodificate quando si accede ai dati dell'immagine.

Utilizzate questo criterio per decodificare immagini più piccole. Potete anche usare questo criterio quando l'applicazione non si basa su effetti e transazioni complesse.

ImageDecodingPolicy.ON_LOAD

Asincrono

Le immagini caricate vengono decodificate al momento del caricamento, prima che l'evento COMPLETE venga inviato.

Ideale per immagini più grandi (maggiori di 10 MP). Se state sviluppando applicazioni per dispositivi mobili basate su AIR con transizioni di pagina, utilizzate il criterio di caricamento bitmap per migliorare le prestazioni apparenti dell'applicazione.

Nota: se il file che viene caricato è un'immagine bitmap e il criterio di decodifica utilizzato è ON_LOAD , l'immagine verrà decodificata in maniera asincrona prima che l'evento COMPLETE venga inviato.

Il codice seguente mostra l'uso della 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);

Potete ancora utilizzare la decodifica ON_DEMAND con i metodi Loader.load() e Loader.loadBytes() . Tuttavia, tutti gli altri metodi che ricevono un oggetto LoaderContext come argomento ignorano gli eventuali valori ImageDecodingPolicy passati.

L'esempio seguente mostra la differenza nella decodifica sincrona e asincrona di un'immagine bitmap:

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

Per una dimostrazione dell'effetto dei diversi criteri di decodifica, vedere Thibaud Imbert: Asynchronous bitmap decoding in the Adobe Flash runtimes (Decodifica bitmap asincrona nei runtime Adobe Flash)