CPU-gebruik minimaliseren

Flash Player 10.1 introduceert twee nieuwe functies die de CPU-verwerking helpen opslaan. Met de functies kan SWF-inhoud worden gepauzeerd en voortgezet wanneer de inhoud offscreen gaat en wordt het aantal instanties van Flash Player op een pagina beperkt.

In Flash Player 10.1 en AIR 2.5 wordt een nieuwe functie op mobiele apparaten geïntroduceerd, waarmee wordt bespaard op CPU-verwerking en zodat de batterij langer meegaat. Deze functie heeft betrekking op de achtergrondverlichting waarover veel mobiele apparaten beschikken. Als een gebruiker bijvoorbeeld tijdens het gebruik van een mobiele toepassing wordt onderbroken en het apparaat niet meer gebruikt, detecteert de runtime wanneer de achtergrondverlichting overgaat naar de slaapmodus. De framesnelheid wordt vervolgens verlaagt tot 4 frames per seconde (fps) en de rendering wordt gepauzeerd. Voor AIR-toepassingen wordt de slaapmodus ook geactiveerd wanneer de toepassing naar de achtergrond wordt verplaatst.

ActionScript-code wordt verder uitgevoerd in slaapmodus, zoals het instellen van de Stage.frameRate -eigenschap op 4 fps. Maar de renderingsstap wordt overgeslagen, zodat de gebruiker niet ziet dat de speler ingesteld is op 4 fps. Er wordt gekozen voor een framesnelheid van 4 fps, in plaats van nul, omdat hierdoor alle verbindingen open kunnen blijven (NetStream, Socket, and NetConnection). Als er op nul overgeschakeld zou worden, zouden open verbindingen onderbroken worden. Er werd gekozen voor een vernieuwingsfrequentie van 250 ms (4 fps), omdat veel producenten van mobiele apparaten deze framesnelheid als hun vernieuwingsfrequentie gebruiken. Als u deze waarde gebruikt, blijft de framesnelheid van de runtime dezelfde als die van het apparaat.

Wanneer de achtergrondverlichting weer wordt ingeschakeld, wordt er doorgegaan met de rendering. De framesnelheid retourneert de oorspronkelijke waarde. Bijvoorbeeld: een mediaspelertoepassing waarmee een gebruiker muziek afspeelt. Als het scherm overschakelt naar de slaapmodus, reageert de runtime op basis van het type inhoud dat wordt afgespeeld. Hier volgt een lijst met situaties en het bijhorende runtimegedrag.

• De achtergrondverlichting schakelt over naar de slaapmodus en er wordt niet-A/V-inhoud afgespeeld. De rendering wordt gepauzeerd en de framesnelheid wordt ingesteld op 4 fps.

• De achtergrondverlichting schakelt over naar de slaapmodus en er wordt A/V-inhoud afgespeeld. De runtime bepaalt dat de achtergrondverlichting altijd aan is, zodat de gebruiker door kan gaan.

• De achtergrondverlichting schakelt over van de slaapmodus naar de aan-modus. De runtime stelt de framesnelheid in op de instelling voor de framesnelheid van het oorspronkelijke SWF-bestand en gaat door met de rendering.

• Flash Player is gepauzeerd terwijl er A/V-inhoud wordt afgespeeld. Flash Player herstelt het standaardsysteemgedrag van de achtergrondverlichting, omdat er geen A/V meer wordt afgespeeld.

• Het mobiele apparaat ontvangt een telefoongesprek terwijl er A/V-inhoud wordt afgespeeld. De rendering wordt gepauzeerd en de framesnelheid wordt ingesteld op 4 fps.

• De slaapmodus van de achtergrondverlichting op een mobiel apparaat wordt uitgeschakeld. De runtime gedraagt zich normaal.

Wanneer de achtergrondverlichting overgaat in de slaapmodus, wordt de rendering gepauzeerd en de framesnelheid vertraagt. Deze functie bespaart op CPU-verwerking, maar u kunt er niet op rekenen dat deze een echte pauze maakt, zoals in een gametoepassing.

U kunt objecten op de juiste wijze vastzetten en vrijgeven met gebruik van de gebeurtenissen REMOVED_FROM_STAGE en ADDED_TO_STAGE .

Om uw code te optimaliseren, moet u uw objecten altijd vastzetten en vrijgeven. Vastzetten en vrijgeven is belangrijk voor alle objecten, maar vooral voor weergaveobjecten. Zelfs als weergaveobjecten niet meer in de weergavelijst staan en wachten op de afvalophaling, kunnen deze nog steeds CPU-intensieve code gebruiken. Ze kunnen bijvoorbeeld nog steeds Event.ENTER_FRAME gebruiken. Het is dus van essentieel belang objecten op de juiste wijze vast te zetten en vrij te geven met de gebeurtenissen Event.REMOVED_FROM_STAGE en Event.ADDED_TO_STAGE . In het volgende voorbeeld wordt in het werkgebied een filmclip afgespeeld die reageert op het toetsenbord:

// Listen to keyboard events 
stage.addEventListener(KeyboardEvent.KEY_DOWN, keyIsDown); 
stage.addEventListener(KeyboardEvent.KEY_UP, keyIsUp); 
  
// Create object to store key states 
var keys:Dictionary = new Dictionary(true); 
  
function keyIsDown(e:KeyboardEvent):void 
{ 
    // Remember that the key was pressed 
    keys[e.keyCode] = true;     
  
    if (e.keyCode==Keyboard.LEFT || e.keyCode==Keyboard.RIGHT) 
    { 
        runningBoy.play(); 
    } 
} 
  
function keyIsUp(e:KeyboardEvent):void 
{ 
    // Remember that the key was released 
    keys[e.keyCode] = false; 
  
    for each (var value:Boolean in keys) 
          if ( value ) return; 
    runningBoy.stop(); 
} 
  
runningBoy.addEventListener(Event.ENTER_FRAME, handleMovement); 
runningBoy.stop(); 
  
var currentState:Number = runningBoy.scaleX; 
var speed:Number = 15; 
  
function handleMovement(e:Event):void 
{ 
    if (keys[Keyboard.RIGHT]) 
    { 
        e.currentTarget.x += speed; 
        e.currentTarget.scaleX = currentState;     
    } else if (keys[Keyboard.LEFT]) 
    { 
        e.currentTarget.x -= speed; 
        e.currentTarget.scaleX = -currentState; 
    } 
}

Afbeelding groot weergeven

Filmclip die interactief werkt met het toetsenbord

Wanneer op de knop Verwijderen wordt geklikt, wordt de filmclip uit de weergavelijst verwijderd.

// Show or remove running boy 
showBtn.addEventListener (MouseEvent.CLICK,showIt); 
removeBtn.addEventListener (MouseEvent.CLICK,removeIt); 
 
function showIt (e:MouseEvent):void 
{ 
    addChild (runningBoy); 
} 
 
function removeIt(e:MouseEvent):void 
{ 
    if (contains(runningBoy)) removeChild(runningBoy); 
}

Zelfs als de filmclip uit de weergavelijst wordt verwijderd, verstuurt deze nog steeds de Event.ENTER_FRAME -gebeurtenis. De filmclip is nog steeds actief, maar wordt niet gerenderd. U verwerkt deze situatie op de juiste wijze door naar de juiste gebeurtenissen te luisteren en gebeurtenislisteners te verwijderen om te voorkomen dat CPU-intensieve code wordt uitgevoerd:

// Listen to Event.ADDED_TO_STAGE and Event.REMOVED_FROM_STAGE 
runningBoy.addEventListener(Event.ADDED_TO_STAGE,activate); 
runningBoy.addEventListener(Event.REMOVED_FROM_STAGE,deactivate); 
 
function activate(e:Event):void 
{ 
    // Restart everything 
    e.currentTarget.addEventListener(Event.ENTER_FRAME,handleMovement); 
} 
 
function deactivate(e:Event):void 
{ 
    // Freeze the running boy - consumes fewer CPU resources when not shown 
    e.currentTarget.removeEventListener(Event.ENTER_FRAME,handleMovement); 
    e.currentTarget.stop(); 
}

Wanneer op de knop Tonen wordt geklikt, wordt de filmclip weer gestart, luistert deze weer naar de gebeurtenissen Event.ENTER_FRAME en bestuurt het toetsenbord de filmclip op de juiste wijze.

Bij Flash Player 10 en AIR 1.5 doet zich nu ook het volgende gedrag voor. Als de afspeelkop een leeg frame ontdekt, wordt het weergaveobject automatisch stilgezet, zelfs als u geen gedrag voor het stilzetten hebt geïmplementeerd.

Het concept van stilzetten is ook belangrijk als u externe inhoud laadt met behulp van de Loader-klasse. Wanneer u in Flash Player 9 en AIR 1.0 de Loader-klasse gebruikt, moet u inhoud handmatig stilzetten door te luisteren naar de Event.UNLOAD -gebeurtenis die door het LoaderInfo-object wordt verstuurd. Elk object moet handmatig worden stilgezet en dit is geen onbelangrijke taak. In Flash Player 10 en AIR 1.5 werd een belangrijke nieuwe methode voor de Loader-klasse geïntroduceerd met de naam unloadAndStop() . Met deze methode kunt u een SWF-bestand ontladen, automatisch elk object in het geladen SWF-bestand vastzetten en de afvalophaling starten.

In de volgende code wordt het SWF-bestand geladen en ontladen met behulp van de unload() -methode, die meer verwerking en handmatige vastzetting vereist.

var loader:Loader = new Loader(); 
 
loader.load ( new URLRequest ( "content.swf" ) ); 
 
addChild ( loader ); 
 
stage.addEventListener ( MouseEvent.CLICK, unloadSWF ); 
 
function unloadSWF ( e:MouseEvent ):void 
{ 
    // Unload the SWF file with no automatic object deactivation 
    // All deactivation must be processed manually 
    loader.unload(); 
}

We raden u aan om de unloadAndStop() -methode te gebruiken, die de vastzetting intern behandelt en het afvalophalingsproces start.

var loader:Loader = new Loader(); 
 
loader.load ( new URLRequest ( "content.swf" ) ); 
 
addChild ( loader ); 
 
stage.addEventListener ( MouseEvent.CLICK, unloadSWF ); 
 
function unloadSWF ( e:MouseEvent ):void 
{ 
    // Unload the SWF file with automatic object deactivation 
    // All deactivation is handled automatically 
    loader.unloadAndStop(); 
}

Als de unloadAndStop() -methode wordt aangeroepen, vinden de volgende acties plaats:

• Geluid wordt gestopt.

• Listeners die zijn geregistreerd voor de hoofdtijdlijn van het SWF-bestand worden verwijderd.

• Timerobjecten worden stopgezet.

• Hardware randapparatuur (zoals camera's en microfoons) worden vrijgegeven.

• Elke filmclip wordt gestopt.

• Het versturen van Event.ENTER_FRAME , Event.FRAME_CONSTRUCTED , Event.EXIT_FRAME , Event.ACTIVATE en Event.DEACTIVATE wordt gestopt.

Gebruik de gebeurtenissen Event.ACTIVATE en Event.DEACTIVATE om inactiviteiten op de achtergrond te detecteren en optimaliseer vervolgens uw toepassing.

Met de twee gebeurtenissen Event.ACTIVATE en Event.DEACTIVATE kunt u uw toepassing nauwkeurig instellen, zodat deze zo min mogelijk CPU-cycli gebruikt. Met deze gebeurtenissen kunt u detecteren wanneer de runtime de focus krijgt of verliest. De code kan als gevolg hiervan worden geoptimaliseerd om te reageren op contextwijzigingen. De volgende code luistert naar beide gebeurtenissen en verandert dynamisch de framesnelheid in nul wanneer de toepassing de focus verliest. De animatie kan bijvoorbeeld de focus verliezen wanneer de gebruiker overschakelt naar een ander tabblad of de toepassing naar de achtergrond verplaatst:

var originalFrameRate:uint = stage.frameRate; 
var standbyFrameRate:uint = 0; 
  
stage.addEventListener ( Event.ACTIVATE, onActivate ); 
stage.addEventListener ( Event.DEACTIVATE, onDeactivate ); 
  
function onActivate ( e:Event ):void 
{ 
    // restore original frame rate 
    stage.frameRate = originalFrameRate; 
} 
  
function onDeactivate ( e:Event ):void 
{ 
    // set frame rate to 0 
    stage.frameRate = standbyFrameRate; 
}

Wanneer de toepassing opnieuw de focus krijgt, wordt de framesnelheid weer ingesteld op de oorspronkelijke waarde. In plaats van de framesnelheid dynamisch te wijzigen, kunt u de toepassing ook op andere manieren optimaliseren, bijvoorbeeld door het stilzetten en het opnieuw activeren van objecten.

Met het activeren en deactiveren van gebeurtenissen kunt u een mechanisme implementeren dat vergelijkbaar is met de functie voor pauzeren en voortzetten die soms op mobiele apparaten en netbooks zijn te vinden.

U kunt proberen muisinteracties waar mogelijk uit te schakelen.

Wanneer u interactieve objecten gebruikt, zoals een MovieClip- of Sprite-object, voert de runtime de interne code uit om muisinteracties te detecteren en te verwerken. Detectie van muisinteractie kan veel van de CPU vergen als vele interactieve objecten op het scherm verschijnen, vooral als ze elkaar overlappen. U kunt dit gemakkelijk voorkomen door muisinteractie uit te schakelen voor objecten waarvoor muisinteractie overbodig is. De volgende code illustreert het gebruik van de eigenschappen mouseEnabled en mouseChildren :

// Disable any mouse interaction with this InteractiveObject 
myInteractiveObject.mouseEnabled = false; 
const MAX_NUM:int = 10; 
  
// Create a container for the InteractiveObjects 
var container:Sprite = new Sprite(); 
  
for ( var i:int = 0; i< MAX_NUM; i++ ) 
{ 
    // Add InteractiveObject to the container 
    container.addChild( new Sprite() ); 
} 
  
// Disable any mouse interaction on all the children 
container.mouseChildren = false;

U kunt indien mogelijk de muisinteracties ook uitschakelen, zodat uw toepassing minder van de CPU vergt en de batterij op het mobiele apparaat dus langer meegaat.

Kies timers of ENTER_FRAME -gebeurtenissen, afhankelijk van het feit of de content geanimeerd is.

Gebruik voor niet-geanimeerde content die gedurende een lange periode wordt uitgevoerd liever timers dan Event.ENTER_FRAME -gebeurtenissen.

U kunt in ActionScript 3.0 op twee verschillende manieren een functie bij een bepaald interval aanroepen. U kunt bijvoorbeeld de gebeurtenis Event.ENTER_FRAME gebruiken die wordt verzonden door weergaveobjecten (DisplayObject). Maar u kunt ook een timer gebruiken. ActionScript-ontwikkelaars kiezen vaak voor de ENTER_FRAME -aanpak. De gebeurtenis ENTER_FRAME wordt op elk frame verzonden. Dat betekent dat het interval waarbij de functie wordt aangeroepen gerelateerd is aan de huidige framesnelheid. De framesnelheid is toegankelijk via de eigenschap Stage.frameRate . In sommige gevallen is het echter beter een timer te gebruiken dan de ENTER_FRAME -gebeurtenis. Als u bijvoorbeeld geen animatie gebruikt, maar de code bij een specifiek interval wilt aanroepen, kunt u beter een timer gebruiken.

Een timer kan net zo functioneren als een ENTER_FRAME -gebeurtenis, maar een gebeurtenis kan worden verzonden zonder te zijn gekoppeld aan de framesnelheid. En dat kan tot aanzienlijke optimalisatie leiden. Laten we een videospelertoepassing als voorbeeld gebruiken. In dit geval hoeft u geen hoge framesnelheid te gebruiken, omdat alleen de besturingselementen van de toepassing zich verplaatsen.

In dit voorbeeld is een lage framesnelheid ingesteld, namelijk 10 fps. De timer werkt de besturingselementen één keer per seconde bij. Deze hogere bijwerksnelheid wordt mogelijk gemaakt door de methode updateAfterEvent() die beschikbaar is op het TimerEvent-object. Iedere keer als de timer een gebeurtenis verzendt, forceert deze methode schermvernieuwing, als dat nodig is. De volgende code illustreert dit:

// Use a low frame rate for the application 
stage.frameRate = 10; 
  
// Choose one update per second 
var updateInterval:int = 1000; 
var myTimer:Timer = new Timer(updateInterval,0); 
  
myTimer.start(); 
myTimer.addEventListener( TimerEvent.TIMER, updateControls ); 
  
function updateControls( e:TimerEvent ):void 
{ 
    // Update controls here 
    // Force the controls to be updated on screen 
    e.updateAfterEvent(); 
}

De framesnelheid wordt niet gewijzigd wanneer de methode updateAfterEvent() wordt aangeroepen. De methode dwingt de runtime alleen om de inhoud op het scherm bij te werken. De snelheid van de tijdlijn blijft 10 fps. Vergeet niet dat timers en ENTER_FRAME -gebeurtenissen niet volledig nauwkeurig zijn op minder geavanceerde apparaten en dat gebeurtenishandlerfuncties met code veel verwerking vereisen. Net als de framesnelheid van het SWF-bestand kan de bijwerkframesnelheid van de timer in bepaalde situaties variëren.

Gebruik in uw toepassing zo weinig mogelijk objecten Timer en geregistreerde handlers enterFrame .

Tijdens elk frame wordt een gebeurtenis enterFrame naar elk weergaveobject in de weergavelijst verzonden. U kunt listeners voor de gebeurtenis enterFrame met meerdere weergaveobjecten registreren, maar dat betekent dat er in elk frame meer code wordt uitgevoerd. Het is beter om één gecentraliseerde enterFrame -handler te gebruiken waarmee alle code voor elk frame wordt uitgevoerd. Als u deze code centraliseert, is het eenvoudiger om alle code die vaak wordt uitgevoerd te beheren.

Als u objecten Timer gebruikt, is er sprake van overhead als gevolg van het maken en verzenden van gebeurtenissen vanaf meerdere objecten Timer. Als u verschillende bewerkingen met verschillende intervallen moet triggeren, kunt u dit ook op de volgende manieren doen:

• Gebruik een zo klein mogelijk aantal objecten Timer en groepbewerkingen, bepaald door het aantal keer dat deze voorkomen.

  Gebruik bijvoorbeeld één Timer voor frequente bewerkingen, die elke 100 milliseconden wordt getriggerd. Gebruik een andere Timer voor minder frequente of achtergrondbewerkingen, die elke 2000 milliseconden wordt getriggerd.

• Gebruik één object Timer en zorg ervoor dat de frequentie waarmee bewerkingen worden getriggerd een meervoud is van het interval van de eigenschap delay van het object Timer.

  Stel dat u bewerkingen hebt die elke 100 milliseconde moeten worden uitgevoerd en bewerkingen die elke 200 milliseconde moeten worden uitgevoerd. In dat geval gebruikt u één object Timer, waarvoor bij delay een waarde van 100 milliseconde is ingesteld. In de gebeurtenishandler timer voegt u een voorwaardelijke instructie toe waarmee de 200-milliseconde-bewerkingen om en om worden uitgevoerd. Deze techniek wordt in het volgende voorbeeld getoond:

  var timer:Timer = new Timer(100); 
  timer.addEventListener(TimerEvent.Timer, timerHandler); 
  timer.start(); 
       
  var offCycle:Boolean = true; 
    
  function timerHandler(event:TimerEvent):void 
  { 
      // Do things that happen every 100 ms 
       
      if (!offCycle) 
      { 
          // Do things that happen every 200 ms 
      } 
       
      offCycle = !offCycle; 
  }

Onderbreek objecten Timer onderbreken wanneer deze niet worden gebruikt.

Als de gebeurtenishandler timer van een object Timer alleen onder bepaalde omstandigheden bewerkingen uitvoert, roept u de methode stop() van het object Timer aan wanneer aan geen van de voorwaarden wordt voldaan.

Zorg ervoor dat in de gebeurtenis enterFrame of Timer-handlers zo weinig mogelijk wijzigingen in de weergave van het object plaatsvinden die tot gevolg hebben dat het scherm opnieuw getekend moet worden.

In elk frame wordt in de renderingfase het gedeelte van het werkgebied dat tijdens dat frame is gewijzigd opnieuw getekend. Als het opnieuw te tekenen gebied groot is, of klein is maar een groot aantal of complexe weergaveobjecten bevat, heeft de runtime meer tijd nodig voor rendering. Met de functie Opnieuw te tekenen gebieden weergeven in de foutopsporingsversie van Flash Player of AIR kunt u testen hoeveel tijd er nodig is voor het opnieuw teken.

U kunt CPU-vermogen besparen door het gebruik van tweening te beperken. Zo bespaart u CPU-verwerking, geheugen en de batterij.

Ontwerpers en ontwikkelaars die desktopcontent voor Flash produceren, gebruiken vaak bewegingstweens in hun toepassingen. Beperk het gebruik van bewegingstweens tot een minimum wanneer u content produceert voor mobiele apparatuur met lage specificaties. De content wordt dan sneller uitgevoerd op dergelijke apparatuur.