Runtime Events

/**
 * Runtime events and console handling for CDP v138
 * @param devtools DevTools connection for event communication
 */
public class v138Events extends Events<ConsoleAPICalled, ExceptionThrown> {
    public v138Events(DevTools devtools);
    
    // Public API methods inherited from Events base class
    public void addConsoleListener(Consumer<ConsoleEvent> listener);
    public void addJavascriptExceptionListener(Consumer<JavascriptException> listener);
    public void disable();
}

import org.openqa.selenium.devtools.v138.v138Events;
import org.openqa.selenium.devtools.DevTools;
import java.util.function.Consumer;

v138Events events = new v138Events(devTools);

// Use public API methods for event handling
events.addConsoleListener(console -> {
    System.out.println("Console " + console.getType() + ": " + 
        console.getArgs().get(0));
});

events.addJavascriptExceptionListener(exception -> {
    System.err.println("JavaScript Error: " + exception.getMessage());
});

/**
 * Add listener for console events (console.log, console.error, etc.)
 * @param listener Consumer that receives ConsoleEvent objects
 */
public void addConsoleListener(Consumer<ConsoleEvent> listener);

/**
 * Add listener for JavaScript exceptions
 * @param listener Consumer that receives JavascriptException objects
 */
public void addJavascriptExceptionListener(Consumer<JavascriptException> listener);

/**
 * Disable all event monitoring and clean up resources
 */
public void disable();

v138Events events = new v138Events(devTools);

// Add console listener - automatically handles event conversion
events.addConsoleListener(console -> {
    System.out.printf("[%s] %s: %s%n",
        console.getTimestamp(),
        console.getType(),
        console.getArgs().get(0));
});

// Add exception listener
events.addJavascriptExceptionListener(exception -> {
    System.err.println("JS Exception: " + exception.getMessage());
    exception.printStackTrace();
});

// Navigate and generate events
driver.get("https://example.com");
driver.executeScript("console.log('Test message'); throw new Error('Test error');");

// Clean up when done
events.disable();

/**
 * Enable Runtime domain to start receiving events
 * @return Command to enable runtime domain
 */
@Override
protected Command<Void> enableRuntime();

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

/**
 * Stream of console API events (console.log, console.error, etc.)
 * @return Event stream for console API calls
 */
@Override
protected Event<ConsoleAPICalled> consoleEvent();

// Listen for all console events
devTools.addListener(events.consoleEvent(), event -> {
    ConsoleEvent converted = events.toConsoleEvent(event);
    System.out.printf("[%s] %s: %s%n", 
        converted.getTimestamp(),
        converted.getType(),
        converted.getArgs().get(0));
});

// Now console.log calls in browser will trigger the listener
driver.executeScript("console.log('Hello from browser!');");

/**
 * Stream of JavaScript exception events
 * @return Event stream for unhandled exceptions
 */
@Override
protected Event<ExceptionThrown> exceptionThrownEvent();

// Listen for JavaScript exceptions
devTools.addListener(events.exceptionThrownEvent(), event -> {
    JavascriptException jsException = events.toJsException(event);
    System.err.println("JavaScript Error: " + jsException.getMessage());
    jsException.printStackTrace();
});

// Now unhandled JavaScript errors will trigger the listener
driver.executeScript("throw new Error('Test exception');");

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

/**
 * Convert CDP ExceptionThrown to JavascriptException
 * @param event Raw CDP exception event
 * @return Java exception with stack trace
 */
@Override
protected JavascriptException toJsException(ExceptionThrown event);

class ConsoleEvent {
    String getType();           // "log", "error", "warn", "info", etc.
    Instant getTimestamp();     // When the event occurred
    List<Object> getArgs();     // Console arguments as RemoteObjects
    List<Object> getRawArgs();  // Original CDP arguments
}

class JavascriptException extends RuntimeException {
    String getMessage();        // Exception message or description
    StackTraceElement[] getStackTrace(); // Reconstructed JavaScript stack
}

import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.devtools.DevTools;
import org.openqa.selenium.devtools.v138.v138Events;

ChromeDriver driver = new ChromeDriver();
DevTools devTools = driver.getDevTools();
devTools.createSession();

v138Events events = new v138Events(devTools);

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

// Monitor console output
devTools.addListener(events.consoleEvent(), event -> {
    ConsoleEvent console = events.toConsoleEvent(event);
    System.out.printf("[Console %s] %s%n", 
        console.getType(), 
        console.getArgs().get(0));
});

// Monitor JavaScript exceptions
devTools.addListener(events.exceptionThrownEvent(), event -> {
    JavascriptException jsError = events.toJsException(event);
    System.err.println("JavaScript Exception: " + jsError.getMessage());
});

// Navigate and execute JavaScript
driver.get("https://example.com");
driver.executeScript("console.log('Page loaded'); console.error('Test error');");

// Clean up
devTools.send(events.disableRuntime());
devTools.close();
driver.quit();