UncaughtErrorEvent

Package	flash.events
Class	public class UncaughtErrorEvent
Inheritance	UncaughtErrorEvent ErrorEvent TextEvent Event Object

Language Version:

ActionScript 3.0

Runtime Versions:

Flash Player 10.1, AIR 2

An UncaughtErrorEvent object is dispatched by an instance of the UncaughtErrorEvents class when an uncaught error occurs. An uncaught error happens when an error is thrown outside of any try..catch blocks or when an ErrorEvent object is dispatched with no registered listeners. The uncaught error event functionality is often described as a "global error handler."

The UncaughtErrorEvents object that dispatches the event is associated with either a LoaderInfo object or a Loader object. Use the following properties to access an UncaughtErrorEvents instance:

LoaderInfo.uncaughtErrorEvents: to detect uncaught errors in code defined in the same SWF.
Loader.uncaughtErrorEvents: to detect uncaught errors in code defined in the SWF loaded by a Loader object.

When an uncaughtError event happens, even if the event is handled, execution does not continue in the call stack that caused the error. If the error is a synchronous error, any code remaining in the function where the error happened is not executed. Consequently, it is likely that when an uncaught error event happens, your application is in an unstable state. Since there can be many causes for an uncaught error, it is impossible to predict what functionality is available. For example, your application may be able to execute network operations or file operations. However, those operations aren't necessarily available.

When one SWF loads another, uncaughtError events bubble down and up again through the LoaderInfo heirarchy. For example, suppose A.swf loads B.swf using a Loader instance. If an uncaught error occurs in B.swf, an uncaughtError event is dispatched to LoaderInfo and Loader objects in the following sequence:

(Capture phase) A.swf's LoaderInfo
(Capture phase) Loader in A.swf
(Target phase) B.swf's LoaderInfo
(Bubble phase) Loader in A.swf
(Bubble phase) A.swf's LoaderInfo

A Loader object's uncaughtErrorEvents property never dispatches an uncaughtErrorEvent in the target phase. It only dispatches the event in the capture and bubbling phases.

As with other event bubbling, calling stopPropagation() or stopImmediatePropagation() stops the event from being dispatched to any other listeners, with one important difference. A Loader object's UncaughtErrorEvents object is treated as a pair with the loaded SWF's LoaderInfo.uncaughtErrorEvents object for event propagation purposes. If a listener registered with one of those objects calls the stopPropagation() method, events are still dispatched to other listeners registered with that UncaughtErrorEvents object and to listeners registered with its partner UncaughtErrorEvents object before event propagation ends. The stopImmediatePropagation() method still prevents events from being dispatched to all additional listeners.

When content is running in a debugger version of the runtime, such as the debugger version of Flash Player or the AIR Debug Launcher (ADL), an uncaught error dialog appears when an uncaught error happens. For those runtime versions, the error dialog appears even when a listener is registered for the uncaughtError event. To prevent the dialog from appearing in that situation, call the UncaughtErrorEvent object's preventDefault() method.

If the content loaded by a Loader object is an AVM1 (ActionScript 2) SWF file, uncaught errors in the AVM1 SWF file do not result in an uncaughtError event. In addition, JavaScript errors in HTML content loaded in an HTMLLoader object (including a Flex HTML control) do not result in an uncaughtError event.

View the examples

Related API Elements

LoaderInfo.uncaughtErrorEvents
Loader.uncaughtErrorEvents
UncaughtErrorEvents

Public Properties

Hide Inherited Public Properties

Show Inherited Public Properties

	Property		Defined By
		bubbles : Boolean [read-only] Indicates whether an event is a bubbling event.	Event
		cancelable : Boolean [read-only] Indicates whether the behavior associated with the event can be prevented.	Event
		constructor : Object A reference to the class object or constructor function for a given object instance.	Object
		currentTarget : Object [read-only] The object that is actively processing the Event object with an event listener.	Event
		error : * [read-only] The error object associated with the uncaught error.	UncaughtErrorEvent
		errorID : int [read-only] Contains the reference number associated with the specific error.	ErrorEvent
		eventPhase : uint [read-only] The current phase in the event flow.	Event
		target : Object [read-only] The event target.	Event
		text : String For a textInput event, the character or sequence of characters entered by the user.	TextEvent
		type : String [read-only] The type of event.	Event

Public Methods

Hide Inherited Public Methods

Show Inherited Public Methods

	Method		Defined By
		UncaughtErrorEvent(type:String, bubbles:Boolean = true, cancelable:Boolean = true, error_in:* = null) Creates an UncaughtErrorEvent object that contains information about an uncaughtError event.	UncaughtErrorEvent
		clone():Event [override] Creates a copy of the UncaughtErrorEvent object and sets the value of each property to match that of the original.	UncaughtErrorEvent
		formatToString(className:String, ... arguments):String A utility function for implementing the toString() method in custom ActionScript 3.0 Event classes.	Event
		hasOwnProperty(name:String):Boolean Indicates whether an object has a specified property defined.	Object
		isDefaultPrevented():Boolean Checks whether the preventDefault() method has been called on the event.	Event
		isPrototypeOf(theClass:Object):Boolean Indicates whether an instance of the Object class is in the prototype chain of the object specified as the parameter.	Object
		preventDefault():void Cancels an event's default behavior if that behavior can be canceled.	Event
		propertyIsEnumerable(name:String):Boolean Indicates whether the specified property exists and is enumerable.	Object
		setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void Sets the availability of a dynamic property for loop operations.	Object
		stopImmediatePropagation():void Prevents processing of any event listeners in the current node and any subsequent nodes in the event flow.	Event
		stopPropagation():void Prevents processing of any event listeners in nodes subsequent to the current node in the event flow.	Event
		toLocaleString():String Returns the string representation of this object, formatted according to locale-specific conventions.	Object
		toString():String [override] Returns a string that contains all the properties of the UncaughtErrorEvent object.	UncaughtErrorEvent
		valueOf():Object Returns the primitive value of the specified object.	Object

Public Constants

Hide Inherited Public Constants

Show Inherited Public Constants

	Constant		Defined By
		UNCAUGHT_ERROR : String = "uncaughtError" [static] Defines the value of the type property of an uncaughtError event object.	UncaughtErrorEvent

Property Detail

error

property

error:* [read-only]

Language Version:

ActionScript 3.0

Runtime Versions:

Flash Player 10.1, AIR 2

The error object associated with the uncaught error. Typically, this object's data type is one of the following:

An Error instance (or one of its subclasses), if the uncaught error is a synchronous error created by a throw statement, such as an error that could have been caught using a try..catch block
An ErrorEvent instance (or one of its subclasses), if the uncaught error is an asynchronous error that dispatches an error event when the error happens

However, the error property can potentially be an object of any data type. ActionScript does not require a throw statement to be used only with Error objects. For example, the following code is legal both at compile time and run time:

Copy

throw new Sprite()

If that throw statement is not caught by a try..catch block, the throw statement triggers an uncaughtError event. In that case, the error property of the UncaughtErrorEvent object that's dispatched is the Sprite object that's constructed in the throw statement.

Consequently, in your uncaughtError listener, you should check the data type of the error property. The following example demonstrates this check:

Copy

         function uncaughtErrorHandler(event:UncaughtErrorEvent):void
         {
             var message:String;
             
             if (event.error is Error)
             {
                 message = Error(event.error).message;
             }
             else if (event.error is ErrorEvent)
             {
                 message = ErrorEvent(event.error).text;
             }
             else
             {
                 message = event.error.toString();
             }
         }

If the error property contains an Error instance (or Error subclass), the available error information varies depending on the version of the runtime in which the content is running, as follows:

In a debugger version of the runtime such as the debugger version of Flash Player or the AIR Debug Launcher (ADL):
- The Error.getStackTrace() method returns the call stack that led to the error
- The Error.message contains the complete error message text
In a non-debuger version of the runtime:
- The Error.getStackTrace() method returns the call stack that led to the error. However, the call stack information doesn't include source file names or line numbers.
- The Error.message property contains a short version of the error message, which is oftan a combination of the Error.errorID and Error.name properties
In a non-debugger version of the runtime (Flash Player 11.4 or earlier and AIR 1.4 or earlier):
- The Error.getStackTrace() method returns null
- The Error.message property contains a short version of the error message, which is oftan a combination of the Error.errorID and Error.name properties

All other properties and methods of the Error class are available in all runtime versions.

Note that if the error property is an ErrorEvent instance, call stack information is never available.

Implementation
public function get error():*

Constructor Detail

()

Constructor

public function UncaughtErrorEvent(type:String, bubbles:Boolean = true, cancelable:Boolean = true, error_in:* = null)

Language Version:

ActionScript 3.0

Runtime Versions:

Flash Player 10.1, AIR 2

Creates an UncaughtErrorEvent object that contains information about an uncaughtError event.

Parameters

	`type:String` (default = `NaN`) — The type of the event.

	`bubbles:Boolean` (default = `true`) — Determines whether the Event object participates in the bubbling stage of the event flow. Event listeners can access this information through the inherited `bubbles` property.

	`cancelable:Boolean` (default = `true`) — Determines whether the Event object can be canceled. Event listeners can access this information through the inherited `cancelable` property.

	`error_in:*` (default = `null`) — The object associated with the error that was not caught or handled (an Error or ErrorEvent object under normal circumstances).

Method Detail

clone

()

method

override public function clone():Event

Language Version:

ActionScript 3.0

Runtime Versions:

Flash Player 10.1, AIR 2

Creates a copy of the UncaughtErrorEvent object and sets the value of each property to match that of the original.

Returns

Event — A new UncaughtErrorEvent object with property values that match those of the original.

toString

()

method

override public function toString():String

Language Version:

ActionScript 3.0

Runtime Versions:

Flash Player 10.1, AIR 2

Returns a string that contains all the properties of the UncaughtErrorEvent object.

Returns

String — A string that contains all the properties of the UncaughtErrorEvent object.

Constant Detail

UNCAUGHT_ERROR

Constant

public static const UNCAUGHT_ERROR:String = "uncaughtError"

Language Version:

ActionScript 3.0

Runtime Versions:

Flash Player 10.1, AIR 2

Defines the value of the type property of an uncaughtError event object.

Note: If in a try block, there is an event dispatcher that calls its event handler, the catch block doesn't catch the error if thrown in event handler. Any error thrown thereafter can be caught by listening to LoaderInfo.uncaughtErrorEvents.

This event has the following properties:

Property	Value
`bubbles`	`true`
`cancelable`	`true`; cancelling the event prevents the uncaught error dialog from appearing in debugger runtime versions
`currentTarget`	The object that is actively processing the Event object with an event listener.
`error`	The uncaught error.
`target`	The LoaderInfo object associated with the SWF where the error happened.
`text`	Text error message.

Examples How to use this example

UncaughtErrorEventExample.1.as

The following example demonstrates the use of an uncaught error event handler to detect uncaught errors in an ActionScript project. The example defines an uncaughtError event handler to detect uncaught errors. It also provides a button that, when clicked, throws an error that is caught by the uncaught error handler.

In the constructor, the code registers a listener for the uncaughtError event dispatched by the LoaderInfo object's uncaughtErrorEvents property.

In the uncaughtErrorHandler() method, the code checks the data type of the error property and responds accordingly.

Copy

package
{
    import flash.display.Sprite;
    import flash.events.ErrorEvent;
    import flash.events.MouseEvent;
    import flash.events.UncaughtErrorEvent;

    public class UncaughtErrorEventExample extends Sprite
    {
        public function UncaughtErrorEventExample()
        {
            loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaughtErrorHandler);
            
            drawUI();
        }
        
        private function uncaughtErrorHandler(event:UncaughtErrorEvent):void
        {
            if (event.error is Error)
            {
                var error:Error = event.error as Error;
                // do something with the error
            }
            else if (event.error is ErrorEvent)
            {
                var errorEvent:ErrorEvent = event.error as ErrorEvent;
                // do something with the error
            }
            else
            {
                // a non-Error, non-ErrorEvent type was thrown and uncaught
            }
        }
        
        private function drawUI():void
        {
            var btn:Sprite = new Sprite();
            btn.graphics.clear();
            btn.graphics.beginFill(0xFFCC00);
            btn.graphics.drawRect(0, 0, 100, 50);
            btn.graphics.endFill();
            addChild(btn);
            btn.addEventListener(MouseEvent.CLICK, clickHandler);
        }
        
        private function clickHandler(event:MouseEvent):void
        {
            throw new Error("Gak!");
        }
    }
}

UncaughtErrorEventExample.1.5.as

The following example is the Flex equivalent of the previous example, using an MXML document instead of an ActionScript class as the root content.

Copy

<?xml version="1.0" encoding="utf-8"?>
<s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009" 
                       xmlns:s="library://ns.adobe.com/flex/spark" 
                       xmlns:mx="library://ns.adobe.com/flex/halo"
                       applicationComplete="applicationCompleteHandler();">
    
    <fx:Script>
        <![CDATA[
            import flash.events.ErrorEvent;
            import flash.events.MouseEvent;
            import flash.events.UncaughtErrorEvent;
            
            private function applicationCompleteHandler():void
            {
                loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaughtErrorHandler);
            }
    
            private function uncaughtErrorHandler(event:UncaughtErrorEvent):void
            {
                if (event.error is Error)
                {
                    var error:Error = event.error as Error;
                    // do something with the error
                }
                else if (event.error is ErrorEvent)
                {
                    var errorEvent:ErrorEvent = event.error as ErrorEvent;
                    // do something with the error
                }
                else
                {
                    // a non-Error, non-ErrorEvent type was thrown and uncaught
                }
            }
            
            private function clickHandler(event:MouseEvent):void
            {
                throw new Error("Gak!");
            }
        ]]>
    </fx:Script>
      
    <s:Button label="Cause Error" click="clickHandler(event);"/>
</s:WindowedApplication>

UncaughtErrorEventExample.2.as

The following example demonstrates the use of an uncaught error event handler to detect uncaught errors in a loaded SWF. The example defines an uncaughtError event handler to detect uncaught errors.

In the constructor, the code creates a Loader object and registers a listener for the uncaughtError event dispatched by the Loader object's uncaughtErrorEvents property.

In the uncaughtErrorHandler() method, the code checks the data type of the error property and responds accordingly.

Copy

package
{
    import flash.display.Loader;
    import flash.display.Sprite;
    import flash.events.ErrorEvent;
    import flash.events.UncaughtErrorEvent;
    import flash.net.URLRequest;

    public class LoaderUncaughtErrorEventExample extends Sprite
    {
        private var ldr:Loader;
        
        public function LoaderUncaughtErrorEventExample()
        {
            ldr = new Loader();
            ldr.load(new URLRequest("child.swf"));
            ldr.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaughtErrorHandler);
        }
        
        private function uncaughtErrorHandler(event:UncaughtErrorEvent):void
        {
            if (event.error is Error)
            {
                var error:Error = event.error as Error;
                // do something with the error
            }
            else if (event.error is ErrorEvent)
            {
                var errorEvent:ErrorEvent = event.error as ErrorEvent;
                // do something with the error
            }
            else
            {
                // a non-Error, non-ErrorEvent type was thrown and uncaught
            }
        }
    }
}

UncaughtErrorEvent - AS3

Classes x

error