Event Handling

/**
 * Initialize events handler for runtime events
 * @param devtools DevTools session instance
 */
public V105Events(DevTools devtools);

/**
 * Enable runtime domain for event monitoring
 * @return Command to enable runtime events
 */
protected Command<Void> enableRuntime();

/**
 * Disable runtime domain
 * @return Command to disable runtime events
 */
protected Command<Void> disableRuntime();

/**
 * Get console API called event stream
 * @return Event stream for console messages
 */
protected Event<ConsoleAPICalled> consoleEvent();

/**
 * Convert CDP console event to Selenium console event
 * @param event CDP console API called event
 * @return Selenium-compatible console event
 */
protected ConsoleEvent toConsoleEvent(ConsoleAPICalled event);

import org.openqa.selenium.devtools.v105.V105Events;
import org.openqa.selenium.devtools.events.ConsoleEvent;

// Initialize events handler
V105Events events = new V105Events(devTools);

// Enable runtime events
devTools.send(events.enableRuntime());

// Listen for console messages
events.consoleEvent().addListener(consoleApiCalled -> {
    ConsoleEvent event = events.toConsoleEvent(consoleApiCalled);
    
    System.out.println("Console " + event.getType() + ": " + event.getMessages());
    System.out.println("Timestamp: " + event.getTimestamp());
});

// Execute JavaScript that logs to console
devTools.send(Runtime.evaluate("console.log('Hello from browser')"));

/**
 * Get JavaScript exception thrown event stream
 * @return Event stream for JavaScript exceptions
 */
protected Event<ExceptionThrown> exceptionThrownEvent();

/**
 * Convert CDP exception to Selenium JavaScript exception
 * @param event CDP exception thrown event
 * @return Selenium JavaScript exception with stack trace
 */
protected JavascriptException toJsException(ExceptionThrown event);

import org.openqa.selenium.JavascriptException;

// Listen for JavaScript exceptions
events.exceptionThrownEvent().addListener(exceptionThrown -> {
    JavascriptException jsException = events.toJsException(exceptionThrown);
    
    System.err.println("JavaScript Error: " + jsException.getMessage());
    
    // Print stack trace
    for (StackTraceElement element : jsException.getStackTrace()) {
        System.err.println("  at " + element.getMethodName() + 
                          " (" + element.getFileName() + ":" + element.getLineNumber() + ")");
    }
});

// Execute JavaScript that throws an exception
devTools.send(Runtime.evaluate("throw new Error('Test exception')"));

/**
 * Events handler extending base Events class
 */
public class V105Events extends Events<ConsoleAPICalled, ExceptionThrown> {
    public V105Events(DevTools devtools);
}

// Initialize and enable events
V105Events events = new V105Events(devTools);
devTools.send(events.enableRuntime());

// Set up multiple event listeners
events.consoleEvent().addListener(this::handleConsoleEvent);
events.exceptionThrownEvent().addListener(this::handleException);

// Execute test code
devTools.send(Runtime.evaluate("console.log('Starting test'); throw new Error('Test error');"));

// Clean up when done
devTools.send(events.disableRuntime());

private void handleConsoleEvent(ConsoleAPICalled event) {
    ConsoleEvent consoleEvent = events.toConsoleEvent(event);
    // Handle console message
}

private void handleException(ExceptionThrown event) {
    JavascriptException exception = events.toJsException(event);
    // Handle JavaScript exception
}

// Events handler implementation
public class V105Events extends Events<ConsoleAPICalled, ExceptionThrown> {
    public V105Events(DevTools devtools);
}

// Selenium console event
public class ConsoleEvent {
    ConsoleEvent(String type, Instant timestamp, List<Object> messages);
    
    String getType();
    Instant getTimestamp();
    List<Object> getMessages();
}

// Selenium JavaScript exception
public class JavascriptException extends RuntimeException {
    JavascriptException(String message);
    
    String getMessage();
    StackTraceElement[] getStackTrace();
    void setStackTrace(StackTraceElement[] stackTrace);
}

// CDP console API called event
public class ConsoleAPICalled {
    ConsoleAPICalled.Type getType();
    Timestamp getTimestamp();
    List<RemoteObject> getArgs();
}

// Console message types
public enum ConsoleAPICalled.Type {
    LOG, DEBUG, INFO, ERROR, WARNING, DIR, DIRXML, TABLE, TRACE, 
    CLEAR, STARTGROUP, STARTGROUPCOLLAPSED, ENDGROUP, ASSERT, 
    PROFILE, PROFILEEND, COUNT, TIMEEND
}

// CDP exception thrown event
public class ExceptionThrown {
    ExceptionDetails getExceptionDetails();
    Timestamp getTimestamp();
}

// Exception details
public class ExceptionDetails {
    String getText();
    int getLineNumber();
    int getColumnNumber();
    Optional<String> getUrl();
    Optional<StackTrace> getStackTrace();
    Optional<RemoteObject> getException();
}

// Stack trace information
public class StackTrace {
    List<CallFrame> getCallFrames();
    Optional<String> getDescription();
}

// Call frame in stack trace
public class CallFrame {
    String getFunctionName();
    String getUrl();
    int getLineNumber();
    int getColumnNumber();
}

// JavaScript remote object
public class RemoteObject {
    RemoteObject.Type getType();
    Optional<Object> getValue();
    Optional<String> getDescription();
}

// Remote object types
public enum RemoteObject.Type {
    OBJECT, FUNCTION, UNDEFINED, STRING, NUMBER, BOOLEAN, SYMBOL, BIGINT
}

// Idealized remote object for Selenium
public class org.openqa.selenium.devtools.idealized.runtime.model.RemoteObject {
    RemoteObject(String type, Object value);
    
    String getType();
    Object getValue();
}

// CDP timestamp
public class Timestamp {
    Timestamp(Number timestamp);
    
    Number toJson();
    String toString();
}