Bitmapafbeeldingen asynchroon decoderen

Flash Player 11 of hoger, Adobe AIR 2.6 of hoger

Wanneer u met bitmapafbeeldingen werkt, kunt u deze op asynchrone wijze decoderen en laden om de prestaties van uw toepassing te verbeteren. In veel gevallen duurt het asynchroon decoderen van een bitmapafbeelding even lang als het synchroon decoderen. De bitmapafbeelding wordt echter gedecodeerd in een aparte thread voordat het verwante Loader-object de gebeurtenis COMPLETE verzendt. U kunt grotere afbeeldingen dus asynchroon decoderen nadat u deze hebt geladen.

Met de klasse ImageDecodingPolicy in het pakket flash.system kunt u het schema voor het laden van de bitmap opgeven. Standaard worden bitmapafbeeldingen synchroon geladen.

Beleid voor het decoderen van bitmaps

Schema voor het laden van bitmaps

Beschrijving

ImageDecodingPolicy.ON_DEMAND

Synchroon

Geladen afbeeldingen worden gedecodeerd wanneer de afbeeldingsgegevens worden benaderd.

Gebruik dit beleid om kleinere afbeeldingen te decoderen. U kunt dit beleid ook gebruiken wanneer uw toepassing niet afhankelijk is van ingewikkelde effecten en overgangen.

ImageDecodingPolicy.ON_LOAD

Asynchroon

Geladen afbeeldingen worden tijdens het laden gedecodeerd, voordat de gebeurtenis COMPLETE wordt verzonden.

Ideaal voor grotere afbeeldingen (groter dan 10 MP). Wanneer u op AIR gebaseerde mobiele toepassingen met paginaovergangen ontwikkelt, gebruikt u dit beleid voor het laden van bitmaps, zodat uw toepassing beter lijkt te presteren.

Opmerking: Als het bestand dat wordt geladen een bitmapafbeelding is en het decoderingsbeleid ON_LOAD wordt gebruikt, wordt de afbeelding asynchroon gedecodeerd voordat de gebeurtenis COMPLETE wordt verzonden.

De volgende code illustreert het gebruik van de klasse 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);

U kunt ON_DEMAND-decodering nog steeds gebruiken met de methoden Loader.load() en Loader.loadBytes(). Alle andere methoden die een LoaderContext-object als een argument gebruiken, negeren alle doorgegeven ImageDecodingPolicy-waarden.

Het volgende voorbeeld illustreert het verschil tussen het asynchroon en synchroon decoderen van een bitmapafbeelding:

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

Zie Thibaud Imbert: Asynchronous bitmap decoding in the Adobe Flash runtimes voor een demo van de gevolgen van verschillende vormen van decoderingsbeleid.