flash.events

# UncaughtErrorEvent - AS3

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:

1. (Capture phase) A.swf's LoaderInfo
2. (Capture phase) Loader in A.swf
3. (Target phase) B.swf's LoaderInfo
4. (Bubble phase) Loader in A.swf
5. (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

### UncaughtErrorEvent

()
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
                }
            }
        }
    }

© 2015 Adobe Systems Incorporated. All rights reserved.
Mon Apr 10 2017, 12:28 PM -07:00