PlayerSession (Apache Flex - FlexJS: Compiler: Parent 0.8.0-SNAPSHOT API)

java.lang.Object
- flash.tools.debugger.concrete.PlayerSession

All Implemented Interfaces:: DProtocolNotifierIF, IsolateController, Session, Runnable

public class PlayerSession
extends Object
implements Session, DProtocolNotifierIF, Runnable, IsolateController

Field Summary

Fields
Modifier and Type Field and Description

static int MAX_STACK_DEPTH

static long MAX_TERMINATE_WAIT_MILLIS

Fields
Modifier and Type	Field and Description
`static int`	`MAX_STACK_DEPTH`
`static long`	`MAX_TERMINATE_WAIT_MILLIS`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`addWatch(long varId, String varName, int type, int tag, int isolateId)` Adds a watchpoint on the given expression
`boolean`	`bind()` Start up the session listening for incoming messages on the socket
`void`	`breakOnCaughtExceptions(boolean b)` The player always halts on exceptions that are not going to be caught; this call allows the debugger to control its behavior when an exception that will be caught is thrown.
`void`	`breakOnCaughtExceptions(boolean b, int isolateId)`
`Value`	`callConstructor(String funcname, Value[] args)` Invokes a constructor in the player.
`Value`	`callConstructorWorker(String funcname, Value[] args, int isolateId)`
`Value`	`callFunction(Value thisValue, String funcname, Value[] args)` Invokes a function.
`Value`	`callFunctionWorker(Value thisValue, String funcname, Value[] args, int isolateId)`
`Location`	`clearBreakpoint(Location local)` Remove a breakpoint at given location.
`boolean`	`clearExceptionBreakpoint(String exceptionClass)` Clears an exception breakpoint.
`boolean`	`clearExceptionBreakpointWorker(String exceptionClass, int isolateId)`
`Watch`	`clearWatch(Watch watch)` Remove a previously created watchpoint.
`static PlayerSession`	`createFromSocket(Socket s, IDebuggerCallbacks debuggerCallbacks)` Deprecated. Use createFromSocketWithOptions
`static PlayerSession`	`createFromSocketWithOptions(Socket s, IDebuggerCallbacks debuggerCallbacks, SessionManager sessionManager)` Creates a session from the socket.
`void`	`disconnected()` Issued when the socket connection to the player is cut
`Value`	`evalAs(Value value, Value type)` Evaluate the ActionScript expression "value as type"
`Value`	`evalAsWorker(Value value, Value type, int isolateId)`
`boolean`	`evalIn(Value property, Value object)` Evaluate the ActionScript expression "property in object"
`boolean`	`evalInstanceof(Value value, String type)` Evaluate the ActionScript expression "value instanceof type"
`boolean`	`evalInstanceof(Value value, Value type)` Evaluate the ActionScript expression "value instanceof type"
`boolean`	`evalInstanceofWorker(Value value, String type, int isolateId)`
`boolean`	`evalInstanceofWorker(Value value, Value type, int isolateId)`
`boolean`	`evalInWorker(Value property, Value object, int isolateId)`
`boolean`	`evalIs(Value value, String type)` Evaluate the ActionScript expression "value is type"
`boolean`	`evalIs(Value value, Value type)` Evaluate the ActionScript expression "value is type"
`boolean`	`evalIsWorker(Value value, String type, int isolateId)`
`boolean`	`evalIsWorker(Value value, Value type, int isolateId)`
`byte[]`	`getActions(int which, int at, int len)` Request a set of actions from the player
`Location[]`	`getBreakpointList()` Get a list of breakpoints
`Exception`	`getDisconnectCause()` Returns the root SocketException that caused the rxMessage() thread to shut down.
`int`	`getEventCount()` Returns the number of events currently in the queue.
`SourceFile`	`getFile(int fileId, int isolateId)` From a given file identifier return a source file object
`Frame[]`	`getFrames()` Returns an array of frames that identify the location and contain arguments, locals and 'this' information for each frame on the function call stack.
`Frame[]`	`getFramesWorker(int isolateId)`
`Value`	`getGlobal(String name)` Looks up a global name, like "MyClass", "String", etc.
`Value`	`getGlobalWorker(String name, int isolateId)`
`Process`	`getLaunchProcess()` Returns the Process object, if any, that triggered this Session.
`DMessageCounter`	`getMessageCounter()`
`boolean`	`getOption(String optionName, boolean defaultValue, int isolateId)` Returns the value of a Flash Player boolean option that was requested by OutGetOption and returned by InOption.
`String`	`getOption(String optionName, String defaultValue, int isolateId)` Returns the value of a Flash Player string option that was requested by OutGetOption and returned by InOption.
`int`	`getPreference(String pref)` Return the value of a particular preference item
`Object`	`getPreferenceAsObject(String pref)`
`Value`	`getPreviousValue(long valueId, int isolateId)` Returns the previous value object for the given id -- that is, the value that that object had the last time the player was suspended.
`Value`	`getRawValue(long valueId, int isolateId)` Returns the current value object for the given id; never requests it from the player.
`SourceLocator`	`getSourceLocator()` Gets the SourceLocator for this session.
`int`	`getSuspendActionIndex()` Return the offset in which the player has suspended itself.
`DSuspendInfo`	`getSuspendInfo()` Obtain all the suspend information
`DSuspendInfo`	`getSuspendInfoIsolate(int isolateId)`
`int`	`getSuspendOffset()` Return the offset in which the player has suspended itself.
`SwfInfo[]`	`getSwfs()` Obtain information about the various SWF(s) that have been loaded into the Player, for this session.
`SwfInfo[]`	`getSwfsWorker(int isolateId)`
`String`	`getURI()` Returns the URL that identifies this Session.
`Value`	`getValue(long valueId)` From a given value identifier return a Value.
`Value`	`getValue(long varId, String name, int isolateId)` Get the value of the variable named 'name' using varId as the context id for the Variable.
`Value`	`getValueWorker(long valueId, int isolateId)`
`Variable[]`	`getVariableList()` Obtains a list of variables that are local to the current halted state.
`Variable[]`	`getVariableListWorker(int isolateId)`
`Watch[]`	`getWatchList()` Get a list of the current watchpoint.
`Watch[]`	`getWatchListWorker(int isolateId)`
`Isolate[]`	`getWorkers()` Get an array of all workers that the debugger knows of.
`IsolateSession`	`getWorkerSession(int isolateId)` Return the worker specific session object that can be used to communicate with that worker.
`boolean`	`isConnected()` Is the Player currently connected for this session.
`boolean`	`isSuspended()` Is the Player currently halted awaiting requests, such as continue, stepOut, stepIn, stepOver.
`boolean`	`isWorkerSuspended(int isolateId)`
`Set<String>`	`keySet()`
`void`	`messageArrived(DMessage msg, DProtocol which)` This is the core routine for decoding incoming messages and deciding what should be done with them.
`DebugEvent`	`nextEvent()` Removes and returns the next event from queue
`boolean`	`playerCanBreakOnAllExceptions()`
`boolean`	`playerCanBreakOnAllExceptions(int isolateId)`
`boolean`	`playerCanCallFunctions()`
`boolean`	`playerCanCallFunctions(int isolateId)`
`boolean`	`playerCanTerminate()`
`boolean`	`playerSupportsGet()`
`int`	`playerVersion()`
`Isolate[]`	`refreshWorkers()` Ask the player again for a list of all workers.
`boolean`	`removeWatch(long varId, String memberName, int isolateId)` Removes a watchpoint on the given expression
`void`	`requestFrame(int depth, int isolateId)` Asks the player to return information regarding our current context which includes this pointer, arguments for current frame, locals, etc.
`void`	`requestFunctionNames(int moduleId, int lineNbr, int isolateId)` Sends a request to the player to obtain function names.
`void`	`requestSwfInfo(int at, int isolateId)` Request information on a particular swf, used by DSwfInfo to fill itself correctly
`void`	`resume()` Continue a halted session.
`void`	`resumeWorker(int isolateId)`
`void`	`run()` A background thread which wakes up periodically and fetches the SWF and SWD from the Player for new movies that have loaded.
`void`	`setAIRLaunchInfo(AIRLaunchInfo airLaunchInfo)`
`Location`	`setBreakpoint(int fileId, int lineNum)` Set a breakpoint on a line within the given file.
`Location`	`setBreakpointWorker(int fileId, int lineNum, int isolateId)`
`boolean`	`setExceptionBreakpoint(String exceptionClass)` Set an exception breakpoint.
`boolean`	`setExceptionBreakpointWorker(String exceptionClass, int isolateId)`
`void`	`setLauncher(ILauncher launcher)` Sets the ILauncher instance which is associated with this session.
`void`	`setLaunchUrl(String url)`
`void`	`setPreference(String pref, int value)` Set a property.
`void`	`setPreferences(Map<String,? extends Object> map)` Set preference If an invalid preference is passed, it will be silently ignored.
`FaultEvent`	`setScalarMember(long varId, String memberName, int type, String value, int isolateId)`
`void`	`setSourceLocator(SourceLocator sourceLocator)` Sets the SourceLocator for this session.
`Watch`	`setWatch(Value v, String memberName, int kind)` Set a watchpoint on a given variable.
`Watch`	`setWatch(Watch watch)` Enables or disables a watchpoint.
`void`	`stepContinue()` Continue the process of stepping.
`void`	`stepContinueWorker(int isolateId)`
`void`	`stepInto()` Step to the next executable source line within the program, will enter into functions.
`void`	`stepIntoWorker(int isolateId)`
`void`	`stepOut()` Step out of the current method/function onto the next executable soruce line.
`void`	`stepOutWorker(int isolateId)`
`void`	`stepOver()` Step to the next executable source line within the program, will NOT enter into functions.
`void`	`stepOverWorker(int isolateId)`
`boolean`	`supportsConcurrency()` Returns whether the target player supports concurrency.
`boolean`	`supportsConcurrency(int isolateId)`
`boolean`	`supportsWatchpoints()` Returns whether the target player supports watchpoints.
`boolean`	`supportsWatchpoints(int isolateId)`
`boolean`	`supportsWideLineNumbers()`
`boolean`	`supportsWideLineNumbers(int isolateId)`
`void`	`suspend()` Halt a running session.
`int`	`suspendReason()` Return the reason that the player has suspended itself.
`int`	`suspendReasonWorker(int isolateId)`
`void`	`suspendWorker(int isolateId)`
`void`	`terminate()` Destroys all objects related to the connection including the process that was tied to this session via SessionManager.launch(), if it exists.
`void`	`unbind()` Permanently stops the debugging session and breaks the connection to the Player
`void`	`waitForEvent()` Events provide a mechanism whereby status information is provided from the Player in a timely fashion.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MAX_STACK_DEPTH
```
public static final int MAX_STACK_DEPTH
```
    See Also:
    Constant Field Values
  - MAX_TERMINATE_WAIT_MILLIS
```
public static final long MAX_TERMINATE_WAIT_MILLIS
```
    See Also:
    Constant Field Values
- Method Detail
  - createFromSocket
```
public static PlayerSession createFromSocket(Socket s,
                             IDebuggerCallbacks debuggerCallbacks)
                                      throws IOException
```
    Deprecated. Use createFromSocketWithOptions
    
    Parameters:
    s -
    debuggerCallbacks -
    
    Returns:
    
    Throws:
    
    IOException
  - createFromSocketWithOptions
```
public static PlayerSession createFromSocketWithOptions(Socket s,
                                        IDebuggerCallbacks debuggerCallbacks,
                                        SessionManager sessionManager)
                                                 throws IOException
```
    Creates a session from the socket. Sets session specific socket settings and stores the callback object.
    
    Parameters:
    s -
    debuggerCallbacks -
    sessionManager -
    
    Returns:
    
    Throws:
    
    IOException
  - getMessageCounter
```
public DMessageCounter getMessageCounter()
```
  - getURI
```
public String getURI()
```
    Description copied from interface: Session
    
    Returns the URL that identifies this Session. Note: this may not be unique across Sessions if the same launching mechanism and SWF are used.
    
    Specified by:
    
    getURI in interface Session
    
    Returns:
    URI received from the connected Player. It identifies the debugging session
  - playerSupportsGet
```
public boolean playerSupportsGet()
```
  - playerVersion
```
public int playerVersion()
```
  - getSourceLocator
```
public SourceLocator getSourceLocator()
```
    Description copied from interface: Session
    
    Gets the SourceLocator for this session. If none has been specified, returns null.
    
    Specified by:
    
    getSourceLocator in interface Session
  - setSourceLocator
```
public void setSourceLocator(SourceLocator sourceLocator)
```
    Description copied from interface: Session
    
    Sets the SourceLocator for this session. This can be used in order to override the default rules used for finding source files.
    
    Specified by:
    
    setSourceLocator in interface Session
  - getLaunchProcess
```
public Process getLaunchProcess()
```
    Description copied from interface: Session
    
    Returns the Process object, if any, that triggered this Session.
    
    Specified by:
    
    getLaunchProcess in interface Session
    
    Returns:
    the Process object that was used to create this Session. If SessionManager.launch() was not used, then null is returned.
  - setPreferences
```
public void setPreferences(Map<String,? extends Object> map)
```
    Set preference If an invalid preference is passed, it will be silently ignored.
  - keySet
```
public Set<String> keySet()
```
  - getPreferenceAsObject
```
public Object getPreferenceAsObject(String pref)
```
  - setPreference
```
public void setPreference(String pref,
                 int value)
```
    Set a property. Special logic for debug message boolean
    
    Specified by:
    
    setPreference in interface Session
    
    Parameters:
    pref - preference name, one of the strings listed above
    value - value to set for preference
  - getPreference
```
public int getPreference(String pref)
```
    Description copied from interface: Session
    
    Return the value of a particular preference item
    
    Specified by:
    
    getPreference in interface Session
    
    Parameters:
    pref - preference name, one of the strings listed in SessionManager
    See Also:
    SessionManager
  - isConnected
```
public boolean isConnected()
```
    Description copied from interface: Session
    
    Is the Player currently connected for this session. This function must be thread-safe.
    
    Specified by:
    
    isConnected in interface Session
    
    Returns:
    true if connection is alive
  - isSuspended
```
public boolean isSuspended()
                    throws NotConnectedException
```
    Description copied from interface: Session
    
    Is the Player currently halted awaiting requests, such as continue, stepOut, stepIn, stepOver. This function is guaranteed to be thread-safe.
    
    Specified by:
    
    isSuspended in interface Session
    
    Returns:
    true if player halted
    
    Throws:
    
    NotConnectedException - if Player is disconnected from Session
  - isWorkerSuspended
```
public boolean isWorkerSuspended(int isolateId)
                          throws NotConnectedException
```
    Specified by:
    
    isWorkerSuspended in interface IsolateController
    
    Throws:
    
    NotConnectedException
    See Also:
    Session.isSuspended()
  - bind
```
public boolean bind()
             throws VersionException
```
    Start up the session listening for incoming messages on the socket
    
    Specified by:
    
    bind in interface Session
    
    Returns:
    true if bind was successful.
    
    Throws:
    
    VersionException - connected to Player which does not support all API completely
  - unbind
```
public void unbind()
```
    Permanently stops the debugging session and breaks the connection to the Player
    
    Specified by:
    
    unbind in interface Session
  - terminate
```
public void terminate()
```
    Destroys all objects related to the connection including the process that was tied to this session via SessionManager.launch(), if it exists.
    
    Specified by:
    
    terminate in interface Session
  - resume
```
public void resume()
            throws NotSuspendedException,
                   NotConnectedException,
                   NoResponseException
```
    Description copied from interface: Session
    
    Continue a halted session. Execution of the ActionScript will commence until a reason for halting exists. That is, a breakpoint is reached or the suspend() method is called.
    This method will NOT block. It will return immediately after the Player resumes execution. Use the isSuspended method to determine when the Player has halted.
    
    Specified by:
    
    resume in interface Session
    
    Throws:
    
    NotSuspendedException - if Player is already running
    
    NotConnectedException - if Player is disconnected from Session
    
    NoResponseException - if times out
  - suspend
```
public void suspend()
             throws SuspendedException,
                    NotConnectedException,
                    NoResponseException
```
    Description copied from interface: Session
    
    Halt a running session. Execution of the ActionScript will stop at the next possible breakpoint.
    This method WILL BLOCK until the Player halts for some reason or an error occurs. During this period, one or more callbacks may be initiated.
    
    Specified by:
    
    suspend in interface Session
    
    Throws:
    
    SuspendedException - if Player is already suspended
    
    NotConnectedException - if Player is disconnected from Session
    
    NoResponseException - if times out
  - getSuspendInfo
```
public DSuspendInfo getSuspendInfo()
```
    Obtain all the suspend information
  - suspendReason
```
public int suspendReason()
```
    Return the reason that the player has suspended itself.
    
    Specified by:
    
    suspendReason in interface Session
    
    Returns:
    see SuspendReason
  - getSuspendOffset
```
public int getSuspendOffset()
```
    Return the offset in which the player has suspended itself. The BreakReason message contains both reason and offset.
  - getSuspendActionIndex
```
public int getSuspendActionIndex()
```
    Return the offset in which the player has suspended itself. The BreakReason message contains both reason and offset.
  - getSwfs
```
public SwfInfo[] getSwfs()
                  throws NoResponseException
```
    Obtain information about the various SWF(s) that have been loaded into the Player, for this session. Note: As SWFs are loaded by the Player a SwfLoadedEvent is fired. At this point, a call to getSwfInfo() will provide updated information.
    
    Specified by:
    
    getSwfs in interface Session
    
    Returns:
    array of records describing the SWFs
    
    Throws:
    
    NoResponseException - if times out
  - requestSwfInfo
```
public void requestSwfInfo(int at,
                  int isolateId)
                    throws NoResponseException
```
    Request information on a particular swf, used by DSwfInfo to fill itself correctly
    
    Throws:
    
    NoResponseException
  - getActions
```
public byte[] getActions(int which,
                int at,
                int len)
                  throws NoResponseException
```
    Request a set of actions from the player
    
    Throws:
    
    NoResponseException
  - stepInto
```
public void stepInto()
              throws NotSuspendedException,
                     NoResponseException,
                     NotConnectedException
```
    Description copied from interface: Session
    
    Step to the next executable source line within the program, will enter into functions.
    This method will NOT block. It will return immediately after the Player resumes execution. Use the isSuspended method to determine when the Player has halted.
    
    Specified by:
    
    stepInto in interface Session
    
    Throws:
    
    NotSuspendedException - if Player is running
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
  - stepOut
```
public void stepOut()
             throws NotSuspendedException,
                    NoResponseException,
                    NotConnectedException
```
    Description copied from interface: Session
    
    Step out of the current method/function onto the next executable soruce line.
    This method will NOT block. It will return immediately after the Player resumes execution. Use the isSuspended method to determine when the Player has halted.
    
    Specified by:
    
    stepOut in interface Session
    
    Throws:
    
    NotSuspendedException - if Player is running
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
  - stepOver
```
public void stepOver()
              throws NotSuspendedException,
                     NoResponseException,
                     NotConnectedException
```
    Description copied from interface: Session
    
    Step to the next executable source line within the program, will NOT enter into functions.
    This method will NOT block. It will return immediately after the Player resumes execution. Use the isSuspended method to determine when the Player has halted.
    
    Specified by:
    
    stepOver in interface Session
    
    Throws:
    
    NotSuspendedException - if Player is running
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
  - stepContinue
```
public void stepContinue()
                  throws NotSuspendedException,
                         NoResponseException,
                         NotConnectedException
```
    Description copied from interface: Session
    
    Continue the process of stepping. This call should only be issued if a previous stepXXX() call was made and the Player suspended execution due to a breakpoint being hit. That is getSuspendReason() == SuspendReason.Break This operation can be used for assisting with the processing of conditional breakpoints.
    
    Specified by:
    
    stepContinue in interface Session
    
    Throws:
    
    NotSuspendedException - if Player is running
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
  - requestFunctionNames
```
public void requestFunctionNames(int moduleId,
                        int lineNbr,
                        int isolateId)
                          throws VersionException,
                                 NoResponseException
```
    Sends a request to the player to obtain function names. The resultant message end up populating the function name array for the given DModule.
    
    Parameters:
    moduleId -
    lineNbr -
    
    Throws:
    
    VersionException
    
    NoResponseException
  - getFile
```
public SourceFile getFile(int fileId,
                 int isolateId)
```
    From a given file identifier return a source file object
  - getBreakpointList
```
public Location[] getBreakpointList()
```
    Get a list of breakpoints
    
    Specified by:
    
    getBreakpointList in interface Session
    
    Returns:
    breakpoints currently set.
  - setBreakpoint
```
public Location setBreakpoint(int fileId,
                     int lineNum)
                       throws NoResponseException,
                              NotConnectedException
```
    Description copied from interface: Session
    
    Set a breakpoint on a line within the given file.
    Warning: setBreakpoint() and clearBreakpoint() do not keep track of how many times they have been called for a given Location. For example, if you make two calls to setBreakpoint() for file X.as line 10, and then one call to clearBreakpoint() for that same file and line, then the breakpoint is gone. So, the caller is responsible for keeping track of whether the user has set two breakpoints at the same location.
    
    Specified by:
    
    setBreakpoint in interface Session
    
    Returns:
    null if breakpoint not set, otherwise Location of breakpoint.
    
    Throws:
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
  - clearBreakpoint
```
public Location clearBreakpoint(Location local)
```
    Description copied from interface: Session
    
    Remove a breakpoint at given location. The Location obtain can be a clone/copy of a Location object returned from a previous call to getBreakpointList().
    Warning: setBreakpoint() and clearBreakpoint() do not keep track of how many times they have been called for a given Location. For example, if you make two calls to setBreakpoint() for file X.as line 10, and then one call to clearBreakpoint() for that same file and line, then the breakpoint is gone. So, the caller is responsible for keeping track of whether the user has set two breakpoints at the same location.
    
    Specified by:
    
    clearBreakpoint in interface Session
    
    Returns:
    null if breakpoint was not removed.
  - getWatchList
```
public Watch[] getWatchList()
                     throws NoResponseException,
                            NotConnectedException
```
    Description copied from interface: Session
    
    Get a list of the current watchpoint. No specific ordering of the watchpoints is implied by the array. Also, the list may contain watchpoints that are no longer relevant due to the variable going out of scope.
    
    Specified by:
    
    getWatchList in interface Session
    
    Returns:
    watchpoints currently set.
    
    Throws:
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
  - getWatchListWorker
```
public Watch[] getWatchListWorker(int isolateId)
                           throws NoResponseException,
                                  NotConnectedException
```
    Specified by:
    
    getWatchListWorker in interface IsolateController
    
    Throws:
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.getWatchList()
  - setWatch
```
public Watch setWatch(Value v,
             String memberName,
             int kind)
               throws NoResponseException,
                      NotConnectedException,
                      NotSupportedException
```
    Description copied from interface: Session
    
    Set a watchpoint on a given variable. A watchpoint is used to suspend Player execution upon access of a particular variable. If the variable upon which the watchpoint is set goes out of scope, the watchpoint will NOT be automatically removed.
    Specification of the variable item to be watched requires two pieces of information (similar to setScalarMember()) The Variable and the name of the particular member to be watched within the variable. For example if the watchpoint is to be applied to 'a.b.c'. First the Value for object 'a.b' must be obtained and then the call setWatch(v, "c", ...) can be issued. The watchpoint can be triggered (i.e. the Player suspended) when either a read or write (or either) occurs on the variable. If the Player is suspended due to a watchpoint being fired, then the suspendReason() call will return SuspendReason.WATCH.
    Setting a watchpoint multiple times on the same variable will result in the old watchpoint being removed from the list and a new watchpoint being added to the end of the list.
    Likewise, if a previously existing watchpoint is modified by specifiying a different kind variable then the old watchpoint will be removed from the list and a new watchpoint will be added to the end of the list.
    
    Specified by:
    
    setWatch in interface Session
    
    Parameters:
    v - the variable, upon whose member, the watch is to be placed.
    kind - access type that will trigger the watchpoint to fire -- read, write, or read/write. See WatchKind.
    
    Returns:
    null if watchpoint was not created.
    
    Throws:
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
    
    NotSupportedException - if the Player does not support watchpoints, or does not support watchpoints on this particular member (e.g. because it is a getter or a dynamic variable).
    See Also:
    WatchKind
  - setWatch
```
public Watch setWatch(Watch watch)
               throws NoResponseException,
                      NotConnectedException,
                      NotSupportedException
```
    Description copied from interface: Session
    
    Enables or disables a watchpoint.
    
    Specified by:
    
    setWatch in interface Session
    
    Parameters:
    watch - the watch to enable or disable
    
    Throws:
    
    NoResponseException
    
    NotConnectedException
    
    NotSupportedException
  - clearWatch
```
public Watch clearWatch(Watch watch)
                 throws NoResponseException,
                        NotConnectedException
```
    Description copied from interface: Session
    
    Remove a previously created watchpoint. The watchpoint that was removed will be returned upon a sucessful call.
    
    Specified by:
    
    clearWatch in interface Session
    
    Returns:
    null if watchpoint was not removed.
    
    Throws:
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
  - getVariableList
```
public Variable[] getVariableList()
                           throws NotSuspendedException,
                                  NoResponseException,
                                  NotConnectedException,
                                  VersionException
```
    Description copied from interface: Session
    
    Obtains a list of variables that are local to the current halted state.
    
    Specified by:
    
    getVariableList in interface Session
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
    
    VersionException
    See Also:
    Frame.getLocals(flash.tools.debugger.Session)
  - getVariableListWorker
```
public Variable[] getVariableListWorker(int isolateId)
                                 throws NotSuspendedException,
                                        NoResponseException,
                                        NotConnectedException,
                                        VersionException
```
    Specified by:
    
    getVariableListWorker in interface IsolateController
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
    
    VersionException
    See Also:
    Session.getVariableList()
  - getFrames
```
public Frame[] getFrames()
                  throws NotConnectedException
```
    Description copied from interface: Session
    
    Returns an array of frames that identify the location and contain arguments, locals and 'this' information for each frame on the function call stack. The 0th frame contains the current location and context for the actionscript program. Likewise getFrames[getFrames().length] is the topmost (or outermost) frame of the call stack.
    
    Specified by:
    
    getFrames in interface Session
    
    Returns:
    array of call frames with 0th element representing the current frame.
    
    Throws:
    
    NotConnectedException - if Player is disconnected from Session
  - requestFrame
```
public void requestFrame(int depth,
                int isolateId)
                  throws NotSuspendedException,
                         NoResponseException,
                         NotConnectedException
```
    Asks the player to return information regarding our current context which includes this pointer, arguments for current frame, locals, etc.
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
  - getValue
```
public Value getValue(long valueId)
               throws NotSuspendedException,
                      NoResponseException,
                      NotConnectedException
```
    Description copied from interface: Session
    
    From a given value identifier return a Value. This call allows tools to access a specific value whenever the Player has suspended. A Value's id is maintained for the life of the Value and is guaranteed not to change. Values that go out of scope are no longer accessible and will result in a null being returned. Also note, that scalar variables do not contain an id that can be referenced in this manner. Therefore the caller must also maintain the 'context' in which the variable was obtained. For example if a Number b exists on a, then the reference 'a.b' must be managed, as the id of 'a' will be needed to obtain the value of 'b'.
    
    Specified by:
    
    getValue in interface Session
    
    Parameters:
    valueId - identifier from Value class or from a call to Value.getId()
    
    Returns:
    null, if value cannot be found or value with the specific id.
    
    Throws:
    
    NotSuspendedException - if Player is running
    
    NoResponseException - if times out
    
    NotConnectedException - if Player is disconnected from Session
  - getValueWorker
```
public Value getValueWorker(long valueId,
                   int isolateId)
                     throws NotSuspendedException,
                            NoResponseException,
                            NotConnectedException
```
    Specified by:
    
    getValueWorker in interface IsolateController
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.getValue(long)
  - getRawValue
```
public Value getRawValue(long valueId,
                int isolateId)
```
    Returns the current value object for the given id; never requests it from the player.
  - getPreviousValue
```
public Value getPreviousValue(long valueId,
                     int isolateId)
```
    Returns the previous value object for the given id -- that is, the value that that object had the last time the player was suspended. Never requests it from the player (because it can't, of course). Returns null if we don't have a value for that id.
  - getGlobal
```
public Value getGlobal(String name)
                throws NotSuspendedException,
                       NoResponseException,
                       NotConnectedException
```
    Description copied from interface: Session
    
    Looks up a global name, like "MyClass", "String", etc.
    
    Specified by:
    
    getGlobal in interface Session
    
    Returns:
    its value, or null if the global does not exist.
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
  - getGlobalWorker
```
public Value getGlobalWorker(String name,
                    int isolateId)
                      throws NotSuspendedException,
                             NoResponseException,
                             NotConnectedException
```
    Specified by:
    
    getGlobalWorker in interface IsolateController
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.getGlobal(String)
  - getValue
```
public Value getValue(long varId,
             String name,
             int isolateId)
               throws NotSuspendedException,
                      NoResponseException,
                      NotConnectedException
```
    Get the value of the variable named 'name' using varId as the context id for the Variable. This call is used to fire getters, where the id must be that of the original object and not the object id of where the getter actually lives. For example a getter a() may live under o.__proto__.__proto__ but you must use the id of o and the name of 'a' in order for the getter to fire correctly. [Note: This paragraph was written for AS2; __proto__ doesn't exist in AS3. TODO: revise this paragraph]
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
  - callFunction
```
public Value callFunction(Value thisValue,
                 String funcname,
                 Value[] args)
                   throws PlayerDebugException
```
    Description copied from interface: Session
    
    Invokes a function. For example, calling callFunction(myobj, "toString", new Value[0]) will call myobj.toString(). Not supported in Player 9 or AIR 1.0. If you call this function and the player to which you are connected doesn't support this feature, this will throw a PlayerDebugException.
    
    Specified by:
    
    callFunction in interface Session
    
    Throws:
    
    PlayerDebugException
  - callFunctionWorker
```
public Value callFunctionWorker(Value thisValue,
                       String funcname,
                       Value[] args,
                       int isolateId)
                         throws PlayerDebugException
```
    Specified by:
    
    callFunctionWorker in interface IsolateController
    
    Throws:
    
    PlayerDebugException
    See Also:
    Session.callFunction(Value, String, Value[])
  - callConstructor
```
public Value callConstructor(String funcname,
                    Value[] args)
                      throws PlayerDebugException
```
    Description copied from interface: Session
    
    Invokes a constructor in the player. Returns the newly created object. Not supported in Player 9 or AIR 1.0. If you call this function and the player to which you are connected doesn't support this feature, this will throw a PlayerDebugException.
    
    Specified by:
    
    callConstructor in interface Session
    
    Throws:
    
    PlayerDebugException
  - callConstructorWorker
```
public Value callConstructorWorker(String funcname,
                          Value[] args,
                          int isolateId)
                            throws PlayerDebugException
```
    Specified by:
    
    callConstructorWorker in interface IsolateController
    
    Throws:
    
    PlayerDebugException
    See Also:
    Session.callConstructor(String, Value[])
  - setScalarMember
```
public FaultEvent setScalarMember(long varId,
                         String memberName,
                         int type,
                         String value,
                         int isolateId)
                           throws NotSuspendedException,
                                  NoResponseException,
                                  NotConnectedException
```
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
  - waitForEvent
```
public void waitForEvent()
                  throws NotConnectedException,
                         InterruptedException
```
    Description copied from interface: Session
    
    Events provide a mechanism whereby status information is provided from the Player in a timely fashion.
    The caller has the option of either polling the event queue via nextEvent() or calling waitForEvent() which blocks the calling thread until one or more events exist in the queue.
    
    Specified by:
    
    waitForEvent in interface Session
    
    Throws:
    
    NotConnectedException - if Session is disconnected from Player
    
    InterruptedException
  - getEventCount
```
public int getEventCount()
```
    Description copied from interface: Session
    
    Returns the number of events currently in the queue. This function is guaranteed to be thread-safe.
    
    Specified by:
    
    getEventCount in interface Session
  - nextEvent
```
public DebugEvent nextEvent()
```
    Description copied from interface: Session
    
    Removes and returns the next event from queue
    
    Specified by:
    
    nextEvent in interface Session
  - addWatch
```
public boolean addWatch(long varId,
               String varName,
               int type,
               int tag,
               int isolateId)
                 throws NoResponseException,
                        NotConnectedException,
                        NotSupportedException
```
    Adds a watchpoint on the given expression
    
    Throws:
    
    NotConnectedException
    
    NoResponseException
    
    NotSupportedException
    
    NotSuspendedException
  - removeWatch
```
public boolean removeWatch(long varId,
                  String memberName,
                  int isolateId)
                    throws NoResponseException,
                           NotConnectedException
```
    Removes a watchpoint on the given expression
    
    Throws:
    
    NotConnectedException
    
    NoResponseException
    
    NotSuspendedException
  - supportsWatchpoints
```
public boolean supportsWatchpoints()
```
    Description copied from interface: Session
    
    Returns whether the target player supports watchpoints.
    
    Specified by:
    
    supportsWatchpoints in interface Session
    
    See Also:
    Session.setWatch(Value, String, int)
  - supportsWatchpoints
```
public boolean supportsWatchpoints(int isolateId)
```
    Specified by:
    
    supportsWatchpoints in interface IsolateController
    
    See Also:
    Session.supportsWatchpoints()
  - playerCanBreakOnAllExceptions
```
public boolean playerCanBreakOnAllExceptions()
```
  - playerCanBreakOnAllExceptions
```
public boolean playerCanBreakOnAllExceptions(int isolateId)
```
    Specified by:
    
    playerCanBreakOnAllExceptions in interface IsolateController
    
    See Also:
    flash.tools.debugger.Session#playerCanBreakOnAllExceptions()
  - supportsConcurrency
```
public boolean supportsConcurrency(int isolateId)
```
  - supportsConcurrency
```
public boolean supportsConcurrency()
```
    Description copied from interface: Session
    
    Returns whether the target player supports concurrency.
    
    Specified by:
    
    supportsConcurrency in interface Session
    
    See Also:
    #setActiveIsolate(Value)
  - supportsWideLineNumbers
```
public boolean supportsWideLineNumbers()
```
  - supportsWideLineNumbers
```
public boolean supportsWideLineNumbers(int isolateId)
```
    Specified by:
    
    supportsWideLineNumbers in interface IsolateController
    
    See Also:
    flash.tools.debugger.Session#supportsWideLineNumbers()
  - playerCanTerminate
```
public boolean playerCanTerminate()
```
  - playerCanCallFunctions
```
public boolean playerCanCallFunctions()
```
  - playerCanCallFunctions
```
public boolean playerCanCallFunctions(int isolateId)
```
    Specified by:
    
    playerCanCallFunctions in interface IsolateController
    
    See Also:
    flash.tools.debugger.Session#playerCanCallFunctions(String)
  - getOption
```
public boolean getOption(String optionName,
                boolean defaultValue,
                int isolateId)
```
    Returns the value of a Flash Player boolean option that was requested by OutGetOption and returned by InOption.
    
    Parameters:
    optionName - the name of the option
    
    Returns:
    its value, or null
  - getOption
```
public String getOption(String optionName,
               String defaultValue,
               int isolateId)
```
    Returns the value of a Flash Player string option that was requested by OutGetOption and returned by InOption.
    
    Parameters:
    optionName - the name of the option
    
    Returns:
    its value, or null
  - disconnected
```
public void disconnected()
```
    Issued when the socket connection to the player is cut
    
    Specified by:
    
    disconnected in interface DProtocolNotifierIF
  - messageArrived
```
public void messageArrived(DMessage msg,
                  DProtocol which)
```
    This is the core routine for decoding incoming messages and deciding what should be done with them. We have registered ourself with DProtocol to be notified when any incoming messages have been received. It is important to note that we should not rely on the contents of the message since it may be reused after we exit this method.
    
    Specified by:
    
    messageArrived in interface DProtocolNotifierIF
  - run
```
public void run()
```
    A background thread which wakes up periodically and fetches the SWF and SWD from the Player for new movies that have loaded. It then uses these to create an instance of MovieMetaData (a class shared with the Profiler) from which fdb can cull function names. This work is done on a background thread because it can take several seconds, and we want the fdb user to be able to execute other commands while it is happening.
    
    Specified by:
    
    run in interface Runnable
  - setLaunchUrl
```
public void setLaunchUrl(String url)
```
  - setAIRLaunchInfo
```
public void setAIRLaunchInfo(AIRLaunchInfo airLaunchInfo)
```
  - breakOnCaughtExceptions
```
public void breakOnCaughtExceptions(boolean b)
                             throws NotSupportedException,
                                    NoResponseException
```
    Description copied from interface: Session
    
    The player always halts on exceptions that are not going to be caught; this call allows the debugger to control its behavior when an exception that *will* be caught is thrown.
    
    Specified by:
    
    breakOnCaughtExceptions in interface Session
    
    Throws:
    
    NotSupportedException - thrown by older players that don't support this feature.
    
    NoResponseException
  - breakOnCaughtExceptions
```
public void breakOnCaughtExceptions(boolean b,
                           int isolateId)
                             throws NotSupportedException,
                                    NoResponseException
```
    Specified by:
    
    breakOnCaughtExceptions in interface IsolateController
    
    Throws:
    
    NotSupportedException
    
    NoResponseException
    See Also:
    Session.breakOnCaughtExceptions(boolean)
  - evalIs
```
public boolean evalIs(Value value,
             Value type)
               throws PlayerDebugException,
                      PlayerFaultException
```
    Description copied from interface: Session
    
    Evaluate the ActionScript expression "value is type"
    
    Specified by:
    
    evalIs in interface Session
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
  - evalIs
```
public boolean evalIs(Value value,
             String type)
               throws PlayerDebugException,
                      PlayerFaultException
```
    Description copied from interface: Session
    
    Evaluate the ActionScript expression "value is type"
    
    Specified by:
    
    evalIs in interface Session
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
  - evalInstanceof
```
public boolean evalInstanceof(Value value,
                     Value type)
                       throws PlayerDebugException,
                              PlayerFaultException
```
    Description copied from interface: Session
    
    Evaluate the ActionScript expression "value instanceof type"
    
    Specified by:
    
    evalInstanceof in interface Session
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
  - evalInstanceof
```
public boolean evalInstanceof(Value value,
                     String type)
                       throws PlayerDebugException,
                              PlayerFaultException
```
    Description copied from interface: Session
    
    Evaluate the ActionScript expression "value instanceof type"
    
    Specified by:
    
    evalInstanceof in interface Session
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
  - evalIsWorker
```
public boolean evalIsWorker(Value value,
                   Value type,
                   int isolateId)
                     throws PlayerDebugException,
                            PlayerFaultException
```
    Specified by:
    
    evalIsWorker in interface IsolateController
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
    See Also:
    Session.evalIs(Value, Value)
  - evalIsWorker
```
public boolean evalIsWorker(Value value,
                   String type,
                   int isolateId)
                     throws PlayerDebugException,
                            PlayerFaultException
```
    Specified by:
    
    evalIsWorker in interface IsolateController
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
    See Also:
    Session.evalIs(Value, String)
  - evalInstanceofWorker
```
public boolean evalInstanceofWorker(Value value,
                           Value type,
                           int isolateId)
                             throws PlayerDebugException,
                                    PlayerFaultException
```
    Specified by:
    
    evalInstanceofWorker in interface IsolateController
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
    See Also:
    Session.evalInstanceof(Value, Value)
  - evalInstanceofWorker
```
public boolean evalInstanceofWorker(Value value,
                           String type,
                           int isolateId)
                             throws PlayerDebugException,
                                    PlayerFaultException
```
    Specified by:
    
    evalInstanceofWorker in interface IsolateController
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
    See Also:
    Session.evalInstanceof(Value, String)
  - evalIn
```
public boolean evalIn(Value property,
             Value object)
               throws PlayerDebugException,
                      PlayerFaultException
```
    Description copied from interface: Session
    
    Evaluate the ActionScript expression "property in object"
    
    Specified by:
    
    evalIn in interface Session
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
  - evalAs
```
public Value evalAs(Value value,
           Value type)
             throws PlayerDebugException,
                    PlayerFaultException
```
    Description copied from interface: Session
    
    Evaluate the ActionScript expression "value as type"
    
    Specified by:
    
    evalAs in interface Session
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
  - getDisconnectCause
```
public Exception getDisconnectCause()
```
    Description copied from interface: Session
    
    Returns the root SocketException that caused the rxMessage() thread to shut down. This works in conjunction with PREF_SOCKET_TIMEOUT and helps in detecting broken connections.
    
    Specified by:
    
    getDisconnectCause in interface Session
  - refreshWorkers
```
public Isolate[] refreshWorkers()
                         throws NotSupportedException,
                                NotSuspendedException,
                                NoResponseException,
                                NotConnectedException
```
    Description copied from interface: Session
    
    Ask the player again for a list of all workers. Use this method with caution as it will also reset all state about workers that the debugger is aware of.
    
    Specified by:
    
    refreshWorkers in interface Session
    
    Throws:
    
    NotSupportedException
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
  - getWorkers
```
public Isolate[] getWorkers()
```
    Description copied from interface: Session
    
    Get an array of all workers that the debugger knows of.
    
    Specified by:
    
    getWorkers in interface Session
  - resumeWorker
```
public void resumeWorker(int isolateId)
                  throws NotSuspendedException,
                         NotConnectedException,
                         NoResponseException
```
    Specified by:
    
    resumeWorker in interface IsolateController
    
    Throws:
    
    NotSuspendedException
    
    NotConnectedException
    
    NoResponseException
    See Also:
    Session.resume()
  - suspendReasonWorker
```
public int suspendReasonWorker(int isolateId)
                        throws NotConnectedException
```
    Specified by:
    
    suspendReasonWorker in interface IsolateController
    
    Throws:
    
    NotConnectedException
    See Also:
    Session.isSuspended()
  - getSuspendInfoIsolate
```
public DSuspendInfo getSuspendInfoIsolate(int isolateId)
```
  - stepContinueWorker
```
public void stepContinueWorker(int isolateId)
                        throws NotSuspendedException,
                               NoResponseException,
                               NotConnectedException
```
    Specified by:
    
    stepContinueWorker in interface IsolateController
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.stepContinue()
  - setBreakpointWorker
```
public Location setBreakpointWorker(int fileId,
                           int lineNum,
                           int isolateId)
                             throws NoResponseException,
                                    NotConnectedException
```
    Specified by:
    
    setBreakpointWorker in interface IsolateController
    
    Throws:
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.setBreakpoint(int, int)
  - getFramesWorker
```
public Frame[] getFramesWorker(int isolateId)
                        throws NotConnectedException
```
    Specified by:
    
    getFramesWorker in interface IsolateController
    
    Throws:
    
    NotConnectedException
    See Also:
    Session.getFrames()
  - getSwfsWorker
```
public SwfInfo[] getSwfsWorker(int isolateId)
                        throws NoResponseException
```
    Specified by:
    
    getSwfsWorker in interface IsolateController
    
    Throws:
    
    NoResponseException
    See Also:
    Session.getSwfs()
  - stepIntoWorker
```
public void stepIntoWorker(int isolateId)
                    throws NotSuspendedException,
                           NoResponseException,
                           NotConnectedException
```
    Specified by:
    
    stepIntoWorker in interface IsolateController
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.stepInto()
  - stepOutWorker
```
public void stepOutWorker(int isolateId)
                   throws NotSuspendedException,
                          NoResponseException,
                          NotConnectedException
```
    Specified by:
    
    stepOutWorker in interface IsolateController
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.stepOut()
  - stepOverWorker
```
public void stepOverWorker(int isolateId)
                    throws NotSuspendedException,
                           NoResponseException,
                           NotConnectedException
```
    Specified by:
    
    stepOverWorker in interface IsolateController
    
    Throws:
    
    NotSuspendedException
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.stepOver()
  - evalInWorker
```
public boolean evalInWorker(Value property,
                   Value object,
                   int isolateId)
                     throws PlayerDebugException,
                            PlayerFaultException
```
    Specified by:
    
    evalInWorker in interface IsolateController
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
    See Also:
    Session.evalIn(Value, Value)
  - evalAsWorker
```
public Value evalAsWorker(Value value,
                 Value type,
                 int isolateId)
                   throws PlayerDebugException,
                          PlayerFaultException
```
    Specified by:
    
    evalAsWorker in interface IsolateController
    
    Throws:
    
    PlayerDebugException
    
    PlayerFaultException
    See Also:
    Session.evalAs(Value, Value)
  - suspendWorker
```
public void suspendWorker(int isolateId)
                   throws SuspendedException,
                          NotConnectedException,
                          NoResponseException
```
    Specified by:
    
    suspendWorker in interface IsolateController
    
    Throws:
    
    SuspendedException
    
    NotConnectedException
    
    NoResponseException
    See Also:
    Session.suspend()
  - getWorkerSession
```
public IsolateSession getWorkerSession(int isolateId)
```
    Description copied from interface: Session
    
    Return the worker specific session object that can be used to communicate with that worker.
    
    Specified by:
    
    getWorkerSession in interface Session
  - setExceptionBreakpoint
```
public boolean setExceptionBreakpoint(String exceptionClass)
                               throws NoResponseException,
                                      NotConnectedException
```
    Description copied from interface: Session
    
    Set an exception breakpoint. Returns true if succeeded.
    
    Specified by:
    
    setExceptionBreakpoint in interface Session
    
    Returns:
    
    Throws:
    
    NoResponseException
    
    NotConnectedException
  - setExceptionBreakpointWorker
```
public boolean setExceptionBreakpointWorker(String exceptionClass,
                                   int isolateId)
                                     throws NoResponseException,
                                            NotConnectedException
```
    Specified by:
    
    setExceptionBreakpointWorker in interface IsolateController
    
    Throws:
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.setExceptionBreakpoint(String)
  - clearExceptionBreakpoint
```
public boolean clearExceptionBreakpoint(String exceptionClass)
                                 throws NoResponseException,
                                        NotConnectedException
```
    Description copied from interface: Session
    
    Clears an exception breakpoint. Returns true if succeeded.
    
    Specified by:
    
    clearExceptionBreakpoint in interface Session
    
    Returns:
    
    Throws:
    
    NoResponseException
    
    NotConnectedException
  - clearExceptionBreakpointWorker
```
public boolean clearExceptionBreakpointWorker(String exceptionClass,
                                     int isolateId)
                                       throws NoResponseException,
                                              NotConnectedException
```
    Specified by:
    
    clearExceptionBreakpointWorker in interface IsolateController
    
    Throws:
    
    NoResponseException
    
    NotConnectedException
    See Also:
    Session.clearExceptionBreakpoint(String)
  - setLauncher
```
public void setLauncher(ILauncher launcher)
```
    Description copied from interface: Session
    
    Sets the ILauncher instance which is associated with this session. ILauncher instance is used to terminate the process at the end of the debugging session.
    
    Specified by:
    
    setLauncher in interface Session
    
    Parameters:
    launcher - ILauncher instance used to launch & terminate the process.

Class PlayerSession

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAX_STACK_DEPTH

MAX_TERMINATE_WAIT_MILLIS

Method Detail

createFromSocket

createFromSocketWithOptions

getMessageCounter

getURI

playerSupportsGet

playerVersion

getSourceLocator

setSourceLocator

getLaunchProcess

setPreferences

keySet

getPreferenceAsObject

setPreference

getPreference

isConnected

isSuspended

isWorkerSuspended

bind

unbind

terminate

resume

suspend

getSuspendInfo

suspendReason

getSuspendOffset

getSuspendActionIndex

getSwfs

requestSwfInfo

getActions

stepInto

stepOut

stepOver

stepContinue

requestFunctionNames

getFile

getBreakpointList

setBreakpoint

clearBreakpoint

getWatchList

getWatchListWorker

setWatch

setWatch

clearWatch

getVariableList

getVariableListWorker

getFrames

requestFrame

getValue

getValueWorker

getRawValue

getPreviousValue

getGlobal

getGlobalWorker

getValue

callFunction

callFunctionWorker

callConstructor

callConstructorWorker

setScalarMember

waitForEvent

getEventCount

nextEvent

addWatch

removeWatch

supportsWatchpoints

supportsWatchpoints

playerCanBreakOnAllExceptions

playerCanBreakOnAllExceptions

supportsConcurrency

supportsConcurrency

supportsWideLineNumbers

supportsWideLineNumbers