Reageren op foutgebeurtenissen en een specifieke status

Flash Player 9 of hoger, Adobe AIR 1.0 of hoger

Een goed merkbare verbetering in de foutafhandeling van ActionScript 3.0 is de ondersteuning voor de afhandeling van foutgebeurtenissen om te kunnen reageren op asynchrone uitvoeringsfouten. (Zie Typen fouten voor een definitie van asynchrone fouten.)

U kunt gebeurtenislisteners en -handlers maken om te reageren op foutgebeurtenissen. Veel klassen verzenden een foutgebeurtenis op dezelfde manier als andere gebeurtenissen. Een instantie van de klasse XMLSocket bijvoorbeeld verzendt normaal gesproken drie typen gebeurtenissen: Event.CLOSE, Event.CONNECT en DataEvent.DATA. Maar wanneer een probleem optreedt, kan de klasse XMLSocket de IOErrorEvent.IOError of de SecurityErrorEvent.SECURITY_ERROR verzenden. Zie Gebeurtenissen afhandelen voor meer informatie over gebeurtenislisteners en -handlers.

Foutgebeurtenissen behoren tot een van de volgende twee categorieën:

  • Foutgebeurtenissen als uitbreiding op de klasse ErrorEvent

    De klasse flash.events.ErrorEvent bevat de eigenschappen en methoden voor het beheer van Flash Player-uitvoeringsfouten met betrekking tot netwerk- en communicatiefouten. De klassen AsyncErrorEvent, IOErrorEvent en SecurityErrorEvent zijn een uitbreiding op de klasse ErrorEvent. Als u de foutopsporingsversie van de Flash-runtime gebruikt, wordt u tijdens runtime middels een dialoogvenster op de hoogte gebracht van foutgebeurtenissen zonder listenerfuncties die de speler tegenkomt.

  • Foutgebeurtenissen op basis van een status

    Foutgebeurtenissen op basis van een status houden verband met de eigenschappen netStatus en status van de netwerk- en communicatieklassen. Als Flash Player of Adobe AIR een probleem tegenkomt bij het lezen of schrijven van gegevens, wordt de waarde van de eigenschap netStatus.info.level of status.level (afhankelijk van het klassenobject dat u gebruikt) gewijzigd in "error". U reageert op deze fout door na te gaan of de eigenschap level de waarde "error" bevat in uw gebeurtenishandlerfunctie.

Werken met foutgebeurtenissen

De klasse ErrorEvent en de bijbehorende subklassen bevatten fouttypen voor de afhandeling van fouten die door Flash runtimes worden verzonden bij het lezen of schrijven van gegevens.

In het volgende voorbeeld wordt zowel een instructie try..catch als foutgebeurtenishandlers gebruikt om fouten weer te geven die tijdens het lezen naar een lokaal bestand zijn gesignaleerd. Met de opmerking ‘hier uw foutafhandelingscode’ wordt bedoeld dat u op die plaats uw eigen meer geavanceerde code voor de foutafhandeling kunt toevoegen om de gebruiker een aantal opties te bieden of om de fout anderszins automatisch af te handelen:

package 
{ 
    import flash.display.Sprite; 
    import flash.errors.IOError; 
    import flash.events.IOErrorEvent; 
    import flash.events.TextEvent; 
    import flash.media.Sound; 
    import flash.media.SoundChannel; 
    import flash.net.URLRequest; 
    import flash.text.TextField; 
    import flash.text.TextFieldAutoSize; 
 
    public class LinkEventExample extends Sprite 
    { 
        private var myMP3:Sound; 
        public function LinkEventExample() 
        { 
            myMP3 = new Sound(); 
            var list:TextField = new TextField(); 
            list.autoSize = TextFieldAutoSize.LEFT; 
            list.multiline = true; 
            list.htmlText = "<a href=\"event:track1.mp3\">Track 1</a><br>"; 
            list.htmlText += "<a href=\"event:track2.mp3\">Track 2</a><br>"; 
            addEventListener(TextEvent.LINK, linkHandler); 
            addChild(list); 
        } 
         
        private function playMP3(mp3:String):void 
        { 
            try 
            { 
                myMP3.load(new URLRequest(mp3)); 
                myMP3.play(); 
            } 
            catch (err:Error) 
            { 
                trace(err.message); 
                // your error-handling code here 
            } 
            myMP3.addEventListener(IOErrorEvent.IO_ERROR, errorHandler); 
        } 
 
        private function linkHandler(linkEvent:TextEvent):void 
        { 
            playMP3(linkEvent.text); 
            // your error-handling code here 
        } 
         
        private function errorHandler(errorEvent:IOErrorEvent):void 
        { 
            trace(errorEvent.text); 
            // your error-handling code here 
        } 
    } 
}

Werken met gebeurtenissen die een statuswijziging inhouden

Flash runtimes kunnen de waarde van de eigenschap netStatus.info.level of status.level dynamisch wijzigen voor klassen die de eigenschap level ondersteunen. De klassen met de eigenschappen netStatus.info.level zijn NetConnection, NetStream en SharedObject. De klassen met de eigenschap status.level zijn HTTPStatusEvent, Camera, Microphone en LocalConnection. U kunt een handlerfunctie schrijven om te reageren op een wijziging in de waarde level en om communicatiefouten bij te houden

In het volgende voorbeeld wordt de functie netStatusHandler() gebruikt om de waarde van de eigenschap level te testen. Als de eigenschap level aangeeft dat een fout is opgetreden, geeft de code de melding dat de videostream is mislukt.

package 
{ 
    import flash.display.Sprite; 
    import flash.events.NetStatusEvent; 
    import flash.events.SecurityErrorEvent; 
    import flash.media.Video; 
    import flash.net.NetConnection; 
    import flash.net.NetStream; 
 
    public class VideoExample extends Sprite 
    { 
        private var videoUrl:String = "Video.flv"; 
        private var connection:NetConnection; 
        private var stream:NetStream; 
 
        public function VideoExample() 
        { 
            connection = new NetConnection(); 
            connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); 
            connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); 
            connection.connect(null); 
        } 
 
        private function netStatusHandler(event:NetStatusEvent):void 
        { 
            if (event.info.level == "error") 
            { 
                trace("Video stream failed") 
            } 
            else  
            { 
                connectStream(); 
            } 
        } 
 
        private function securityErrorHandler(event:SecurityErrorEvent):void 
        { 
            trace("securityErrorHandler: " + event); 
        } 
 
        private function connectStream():void 
        { 
            var stream:NetStream = new NetStream(connection); 
            var video:Video = new Video(); 
            video.attachNetStream(stream); 
            stream.play(videoUrl); 
            addChild(video); 
        } 
    } 
}