Event Handling

public class EventFiringWebDriver implements WebDriver, JavascriptExecutor, TakesScreenshot, WrapsDriver, HasInputDevices, HasTouchScreen, Interactive, HasCapabilities {
    /**
     * Create EventFiringWebDriver wrapper around existing WebDriver
     */
    public EventFiringWebDriver(WebDriver driver);
    
    /**
     * Register an event listener to receive WebDriver events
     */
    public EventFiringWebDriver register(WebDriverEventListener eventListener);
    
    /**
     * Unregister an event listener
     */
    public EventFiringWebDriver unregister(WebDriverEventListener eventListener);
    
    /**
     * Get the wrapped WebDriver instance
     */
    public WebDriver getWrappedDriver();
    
    // All WebDriver methods with event firing
    public void get(String url);
    public String getCurrentUrl();
    public String getTitle();
    public List<WebElement> findElements(By by);
    public WebElement findElement(By by);
    public String getPageSource();
    public void close();
    public void quit();
    public Set<String> getWindowHandles();
    public String getWindowHandle();
    public TargetLocator switchTo();
    public Navigation navigate();
    public Options manage();
    
    // JavascriptExecutor methods with event firing
    public Object executeScript(String script, Object... args);
    public Object executeAsyncScript(String script, Object... args);
    
    // TakesScreenshot methods with event firing
    public <X> X getScreenshotAs(OutputType<X> target) throws WebDriverException;
}

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.events.EventFiringWebDriver;
import org.openqa.selenium.support.events.WebDriverEventListener;

// Create regular WebDriver
WebDriver driver = new ChromeDriver();

// Wrap with EventFiringWebDriver
EventFiringWebDriver eventDriver = new EventFiringWebDriver(driver);

// Register event listener
eventDriver.register(new MyEventListener());

// Use normally - all actions will fire events
eventDriver.get("https://example.com");
eventDriver.findElement(By.id("button")).click();

// Clean up
eventDriver.quit();

public interface WebDriverEventListener {
    /**
     * Called before Alert.accept()
     */
    void beforeAlertAccept(WebDriver driver);
    
    /**
     * Called after Alert.accept()
     */
    void afterAlertAccept(WebDriver driver);
    
    /**
     * Called before Alert.dismiss()
     */
    void beforeAlertDismiss(WebDriver driver);
    
    /**
     * Called after Alert.dismiss()
     */
    void afterAlertDismiss(WebDriver driver);
    
    /**
     * Called before navigation to URL
     */
    void beforeNavigateTo(String url, WebDriver driver);
    
    /**
     * Called after navigation to URL
     */
    void afterNavigateTo(String url, WebDriver driver);
    
    /**
     * Called before back navigation
     */
    void beforeNavigateBack(WebDriver driver);
    
    /**
     * Called after back navigation
     */
    void afterNavigateBack(WebDriver driver);
    
    /**
     * Called before forward navigation
     */
    void beforeNavigateForward(WebDriver driver);
    
    /**
     * Called after forward navigation
     */
    void afterNavigateForward(WebDriver driver);
    
    /**
     * Called before page refresh
     */
    void beforeNavigateRefresh(WebDriver driver);
    
    /**
     * Called after page refresh
     */
    void afterNavigateRefresh(WebDriver driver);
    
    /**
     * Called before element location
     */
    void beforeFindBy(By by, WebElement element, WebDriver driver);
    
    /**
     * Called after element location
     */
    void afterFindBy(By by, WebElement element, WebDriver driver);
    
    /**
     * Called before element click
     */
    void beforeClickOn(WebElement element, WebDriver driver);
    
    /**
     * Called after element click
     */
    void afterClickOn(WebElement element, WebDriver driver);
    
    /**
     * Called before element value change (sendKeys, clear)
     */
    void beforeChangeValueOf(WebElement element, WebDriver driver, CharSequence[] keysToSend);
    
    /**
     * Called after element value change
     */
    void afterChangeValueOf(WebElement element, WebDriver driver, CharSequence[] keysToSend);
    
    /**
     * Called before JavaScript execution
     */
    void beforeScript(String script, WebDriver driver);
    
    /**
     * Called after JavaScript execution
     */
    void afterScript(String script, WebDriver driver);
    
    /**
     * Called before window switch
     */
    void beforeSwitchToWindow(String windowName, WebDriver driver);
    
    /**
     * Called after window switch
     */
    void afterSwitchToWindow(String windowName, WebDriver driver);
    
    /**
     * Called when any WebDriver operation throws an exception
     */
    void onException(Throwable throwable, WebDriver driver);
    
    /**
     * Called before screenshot capture
     */
    <X> void beforeGetScreenshotAs(OutputType<X> target);
    
    /**
     * Called after screenshot capture
     */
    <X> void afterGetScreenshotAs(OutputType<X> target, X screenshot);
    
    /**
     * Called before getText() on element
     */
    void beforeGetText(WebElement element, WebDriver driver);
    
    /**
     * Called after getText() on element
     */
    void afterGetText(WebElement element, WebDriver driver, String text);
}

public abstract class AbstractWebDriverEventListener implements WebDriverEventListener {
    // Empty implementations of all WebDriverEventListener methods
    // Extend this class and override only the methods you need
    
    public void beforeAlertAccept(WebDriver driver) {}
    public void afterAlertAccept(WebDriver driver) {}
    public void beforeAlertDismiss(WebDriver driver) {}
    public void afterAlertDismiss(WebDriver driver) {}
    public void beforeNavigateTo(String url, WebDriver driver) {}
    public void afterNavigateTo(String url, WebDriver driver) {}
    public void beforeNavigateBack(WebDriver driver) {}
    public void afterNavigateBack(WebDriver driver) {}
    public void beforeNavigateForward(WebDriver driver) {}
    public void afterNavigateForward(WebDriver driver) {}
    public void beforeNavigateRefresh(WebDriver driver) {}
    public void afterNavigateRefresh(WebDriver driver) {}
    public void beforeFindBy(By by, WebElement element, WebDriver driver) {}
    public void afterFindBy(By by, WebElement element, WebDriver driver) {}
    public void beforeClickOn(WebElement element, WebDriver driver) {}
    public void afterClickOn(WebElement element, WebDriver driver) {}
    public void beforeChangeValueOf(WebElement element, WebDriver driver, CharSequence[] keysToSend) {}
    public void afterChangeValueOf(WebElement element, WebDriver driver, CharSequence[] keysToSend) {}
    public void beforeScript(String script, WebDriver driver) {}
    public void afterScript(String script, WebDriver driver) {}
    public void beforeSwitchToWindow(String windowName, WebDriver driver) {}
    public void afterSwitchToWindow(String windowName, WebDriver driver) {}
    public void onException(Throwable throwable, WebDriver driver) {}
    public <X> void beforeGetScreenshotAs(OutputType<X> target) {}
    public <X> void afterGetScreenshotAs(OutputType<X> target, X screenshot) {}
    public void beforeGetText(WebElement element, WebDriver driver) {}
    public void afterGetText(WebElement element, WebDriver driver, String text) {}
}

import org.openqa.selenium.support.events.AbstractWebDriverEventListener;
import java.util.logging.Logger;

public class LoggingEventListener extends AbstractWebDriverEventListener {
    private static final Logger LOG = Logger.getLogger(LoggingEventListener.class.getName());
    
    @Override
    public void beforeNavigateTo(String url, WebDriver driver) {
        LOG.info("Navigating to: " + url);
    }
    
    @Override
    public void afterNavigateTo(String url, WebDriver driver) {
        LOG.info("Successfully navigated to: " + url);
    }
    
    @Override
    public void beforeClickOn(WebElement element, WebDriver driver) {
        LOG.info("Clicking on element: " + element.toString());
    }
    
    @Override
    public void afterClickOn(WebElement element, WebDriver driver) {
        LOG.info("Successfully clicked on element");
    }
    
    @Override
    public void beforeChangeValueOf(WebElement element, WebDriver driver, CharSequence[] keysToSend) {
        LOG.info("Typing into element: " + element.toString() + 
                " with text: " + Arrays.toString(keysToSend));
    }
    
    @Override
    public void onException(Throwable throwable, WebDriver driver) {
        LOG.severe("Exception occurred: " + throwable.getMessage());
    }
}

public class ScreenshotOnFailureListener extends AbstractWebDriverEventListener {
    private final String screenshotDir;
    
    public ScreenshotOnFailureListener(String screenshotDir) {
        this.screenshotDir = screenshotDir;
    }
    
    @Override
    public void onException(Throwable throwable, WebDriver driver) {
        if (driver instanceof TakesScreenshot) {
            String filename = "failure_" + System.currentTimeMillis() + ".png";
            File screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
            try {
                Files.copy(screenshot.toPath(), 
                          Paths.get(screenshotDir, filename));
                System.out.println("Screenshot saved: " + filename);
            } catch (IOException e) {
                System.err.println("Failed to save screenshot: " + e.getMessage());
            }
        }
    }
}

public class PerformanceMonitorListener extends AbstractWebDriverEventListener {
    private final Map<String, Long> operationTimes = new HashMap<>();
    
    @Override
    public void beforeNavigateTo(String url, WebDriver driver) {
        operationTimes.put("navigation_" + url, System.currentTimeMillis());
    }
    
    @Override
    public void afterNavigateTo(String url, WebDriver driver) {
        Long startTime = operationTimes.remove("navigation_" + url);
        if (startTime != null) {
            long duration = System.currentTimeMillis() - startTime;
            System.out.println("Navigation to " + url + " took " + duration + "ms");
        }
    }
    
    @Override
    public void beforeClickOn(WebElement element, WebDriver driver) {
        operationTimes.put("click_" + element.hashCode(), System.currentTimeMillis());
    }
    
    @Override
    public void afterClickOn(WebElement element, WebDriver driver) {
        Long startTime = operationTimes.remove("click_" + element.hashCode());
        if (startTime != null) {
            long duration = System.currentTimeMillis() - startTime;
            System.out.println("Click operation took " + duration + "ms");
        }
    }
    
    @Override
    public void beforeScript(String script, WebDriver driver) {
        operationTimes.put("script_" + script.hashCode(), System.currentTimeMillis());
    }
    
    @Override
    public void afterScript(String script, WebDriver driver) {
        Long startTime = operationTimes.remove("script_" + script.hashCode());
        if (startTime != null) {
            long duration = System.currentTimeMillis() - startTime;
            System.out.println("JavaScript execution took " + duration + "ms");
        }
    }
}

public class EventFiringKeyboard implements Keyboard {
    /**
     * Keyboard wrapper for event firing (internal use)
     */
    public EventFiringKeyboard(WebDriver driver, WebDriverEventListener dispatcher);
    
    public void sendKeys(CharSequence... keysToSend);
    public void pressKey(CharSequence keyToPress);
    public void releaseKey(CharSequence keyToRelease);
}

public class EventFiringMouse implements Mouse {
    /**
     * Mouse wrapper for event firing (internal use)
     */
    public EventFiringMouse(WebDriver driver, WebDriverEventListener dispatcher);
    
    public void click(Coordinates where);
    public void doubleClick(Coordinates where);
    public void mouseDown(Coordinates where);
    public void mouseUp(Coordinates where);
    public void mouseMove(Coordinates where);
    public void mouseMove(Coordinates where, long xOffset, long yOffset);
    public void contextClick(Coordinates where);
}

public class EventFiringTouch implements TouchScreen {
    /**
     * TouchScreen wrapper for event firing (internal use)
     */
    public EventFiringTouch(WebDriver driver, WebDriverEventListener dispatcher);
    
    public void singleTap(Coordinates where);
    public void down(int x, int y);
    public void up(int x, int y);
    public void move(int x, int y);
    public void scroll(Coordinates where, int xOffset, int yOffset);
    public void doubleTap(Coordinates where);
    public void longPress(Coordinates where);
    public void scroll(int xOffset, int yOffset);
    public void flick(int xSpeed, int ySpeed);
    public void flick(Coordinates where, int xOffset, int yOffset, int speed);
}

EventFiringWebDriver eventDriver = new EventFiringWebDriver(driver);

// Register multiple listeners for different purposes
eventDriver.register(new LoggingEventListener());
eventDriver.register(new ScreenshotOnFailureListener("screenshots/"));
eventDriver.register(new PerformanceMonitorListener());
eventDriver.register(new CustomValidationListener());

// All listeners will receive events
eventDriver.get("https://example.com");

public class ConditionalEventListener extends AbstractWebDriverEventListener {
    private boolean enableLogging = true;
    private boolean enableScreenshots = false;
    
    public void setLoggingEnabled(boolean enabled) {
        this.enableLogging = enabled;
    }
    
    public void setScreenshotsEnabled(boolean enabled) {
        this.enableScreenshots = enabled;
    }
    
    @Override
    public void beforeClickOn(WebElement element, WebDriver driver) {
        if (enableLogging) {
            System.out.println("Clicking: " + element.getTagName());
        }
    }
    
    @Override
    public void onException(Throwable throwable, WebDriver driver) {
        if (enableScreenshots && driver instanceof TakesScreenshot) {
            // Take screenshot on exception
            captureScreenshot(driver);
        }
    }
}

public class DataCollectionListener extends AbstractWebDriverEventListener {
    private final List<EventData> events = new ArrayList<>();
    
    @Override
    public void afterNavigateTo(String url, WebDriver driver) {
        events.add(new EventData("navigation", url, System.currentTimeMillis()));
    }
    
    @Override
    public void afterClickOn(WebElement element, WebDriver driver) {
        String elementInfo = element.getTagName() + 
                           (element.getAttribute("id") != null ? 
                            "#" + element.getAttribute("id") : "");
        events.add(new EventData("click", elementInfo, System.currentTimeMillis()));
    }
    
    public List<EventData> getCollectedEvents() {
        return new ArrayList<>(events);
    }
    
    public void clearEvents() {
        events.clear();
    }
    
    public static class EventData {
        public final String type;
        public final String details;
        public final long timestamp;
        
        public EventData(String type, String details, long timestamp) {
            this.type = type;
            this.details = details;
            this.timestamp = timestamp;
        }
    }
}