0
# Selenium DevTools v85
1
2
Selenium DevTools v85 provides Java bindings for the Chrome DevTools Protocol (CDP) targeting Chromium version 85. This package contains the version-specific implementation classes that are automatically discovered and used by the Selenium DevTools framework. While users typically interact with the high-level DevTools API, this package provides the underlying v85-specific functionality for network monitoring, JavaScript execution, console events, logging, and target management.
3
4
## Package Information
5
6
- **Package Name**: selenium-devtools-v85
7
- **Package Type**: maven
8
- **Language**: Java
9
- **Installation**: Add to your Maven dependencies:
10
11
```xml
12
<dependency>
13
<groupId>org.seleniumhq.selenium</groupId>
14
<artifactId>selenium-devtools-v85</artifactId>
15
<version>4.29.0</version>
16
</dependency>
17
```
18
19
## Core Imports
20
21
```java
22
import org.openqa.selenium.devtools.v85.V85Domains;
23
import org.openqa.selenium.devtools.v85.V85CdpInfo;
24
import org.openqa.selenium.devtools.DevTools;
25
```
26
27
## Basic Usage
28
29
**High-Level API (Recommended):**
30
Users typically access DevTools functionality through the high-level API, which automatically uses this v85 implementation when connected to a compatible Chromium version:
31
32
```java
33
import org.openqa.selenium.chrome.ChromeDriver;
34
import org.openqa.selenium.devtools.DevTools;
35
import org.openqa.selenium.devtools.HasDevTools;
36
import org.openqa.selenium.devtools.events.ConsoleEvent;
37
38
// Create Chrome driver with DevTools
39
ChromeDriver driver = new ChromeDriver();
40
DevTools devTools = ((HasDevTools) driver).getDevTools();
41
devTools.createSession();
42
43
// Use high-level API - automatically uses v85 implementation
44
devTools.getDomains().events().addConsoleListener(event -> {
45
System.out.println("Console: " + event.getType() + " - " + event.getMessages());
46
});
47
48
// Network interception (high-level API)
49
devTools.getDomains().network().interceptTrafficWith(filter -> {
50
// Process HTTP requests and responses
51
return req -> {
52
// Process request and return response or NetworkInterceptor.PROCEED_WITH_REQUEST
53
return org.openqa.selenium.devtools.NetworkInterceptor.PROCEED_WITH_REQUEST;
54
};
55
});
56
57
// Close session when done
58
devTools.close();
59
driver.quit();
60
```
61
62
**Direct v85 API (Internal):**
63
This package also provides direct access to v85-specific classes for advanced use cases:
64
65
```java
66
import org.openqa.selenium.devtools.v85.V85Domains;
67
import org.openqa.selenium.devtools.v85.runtime.Runtime;
68
import org.openqa.selenium.devtools.v85.runtime.model.ConsoleAPICalled;
69
import java.util.Optional;
70
71
// Access v85 implementation directly
72
V85Domains domains = new V85Domains(devTools);
73
74
// Enable runtime and monitor console events
75
devTools.send(Runtime.enable());
76
devTools.addListener(Runtime.consoleAPICalled(), event -> {
77
System.out.println("Console: " + event.getType() + " - " + event.getArgs());
78
});
79
```
80
81
## Architecture
82
83
The DevTools v85 package is built around several key components:
84
85
- **Service Discovery**: V85CdpInfo is auto-discovered via @AutoService annotation and registered for Chromium v85
86
- **V85Domains**: Central entry point providing access to all CDP domains for v85
87
- **Domain Handlers**: Specialized v85 implementations for each CDP domain (Network, JavaScript, Events, etc.)
88
- **Generated CDP Classes**: Auto-generated Java classes from CDP protocol definitions for v85
89
- **Event System**: Asynchronous event handling for real-time browser notifications
90
- **Command/Response Pattern**: Type-safe CDP command execution with structured responses
91
92
**Service Discovery Pattern:**
93
This package uses Google's AutoService to automatically register the V85CdpInfo class, which tells the DevTools framework that this implementation supports Chromium version 85. When a DevTools session connects to a compatible browser, this implementation is automatically selected and used.
94
95
## Capabilities
96
97
### Network Interception
98
99
Network monitoring and HTTP request/response interception capabilities. Monitor network traffic, modify requests/responses, handle authentication challenges, and control caching behavior.
100
101
```java { .api }
102
public class V85Network extends Network<AuthRequired, RequestPaused> {
103
public V85Network(DevTools devTools);
104
105
// Public methods accessible to the DevTools framework
106
public Event<RequestPaused> requestPausedEvent();
107
public Either<HttpRequest, HttpResponse> createSeMessages(RequestPaused pausedReq);
108
109
// Note: Most functionality is accessed through high-level DevTools API:
110
// devTools.getDomains().network().interceptTraffic(...)
111
// devTools.getDomains().network().disable()
112
}
113
```
114
115
[Network Interception](./network.md)
116
117
### JavaScript Execution
118
119
JavaScript execution in different browser contexts with binding support. Execute scripts, create persistent bindings between browser and Java, and inject scripts on page load.
120
121
```java { .api }
122
public class V85Javascript extends Javascript<ScriptIdentifier, BindingCalled> {
123
public V85Javascript(DevTools devtools);
124
125
// Note: JavaScript functionality is typically accessed through:
126
// devTools.getDomains().javascript().pin("script")
127
// devTools.getDomains().javascript().addJsBinding("name", callback)
128
// Or direct CDP commands: Runtime.addBinding(), Runtime.evaluate()
129
}
130
```
131
132
[JavaScript Execution](./javascript.md)
133
134
### Console and Runtime Events
135
136
Runtime event monitoring including console API calls, JavaScript exceptions, and error handling. Capture browser console output and JavaScript runtime errors in real-time.
137
138
```java { .api }
139
public class V85Events extends Events<ConsoleAPICalled, ExceptionThrown> {
140
public V85Events(DevTools devtools);
141
142
// Note: Console events are typically accessed through:
143
// devTools.getDomains().events().addConsoleListener(event -> {...})
144
// devTools.getDomains().events().addJavascriptExceptionListener(exception -> {...})
145
}
146
```
147
148
[Console and Events](./events.md)
149
150
### Browser Logging
151
152
Browser log capture and management. Access browser logs with different severity levels and timestamps for debugging and monitoring.
153
154
```java { .api }
155
public class V85Log implements org.openqa.selenium.devtools.idealized.log.Log {
156
public Command<Void> enable();
157
public Command<Void> clear();
158
public Event<LogEntry> entryAdded();
159
}
160
```
161
162
[Browser Logging](./logging.md)
163
164
### Target Management
165
166
Browser target (tab/window) management and session handling. Create, attach to, and manage browser contexts and targets for multi-tab automation.
167
168
```java { .api }
169
public class V85Target implements org.openqa.selenium.devtools.idealized.target.Target {
170
public Command<List<TargetInfo>> getTargets();
171
public Command<SessionID> attachToTarget(TargetID targetId);
172
public Command<Void> detachFromTarget(Optional<SessionID> sessionId, Optional<TargetID> targetId);
173
public Command<Void> setAutoAttach();
174
public Event<TargetID> detached();
175
}
176
```
177
178
[Target Management](./target.md)
179
180
## Core Types
181
182
```java { .api }
183
/**
184
* Main CDP information and version handler
185
*/
186
public class V85CdpInfo extends CdpInfo {
187
public V85CdpInfo();
188
}
189
190
/**
191
* Central domain access point
192
*/
193
public class V85Domains implements Domains {
194
public V85Domains(DevTools devtools);
195
public Events<?, ?> events();
196
public Javascript<?, ?> javascript();
197
public Network<?, ?> network();
198
public Target target();
199
public Log log();
200
}
201
202
/**
203
* User agent configuration for network requests (nested class in Network)
204
*/
205
public static class Network.UserAgent {
206
public UserAgent(String userAgent);
207
public UserAgent acceptLanguage(String acceptLanguage);
208
public UserAgent platform(String platform);
209
public String userAgent();
210
public Optional<String> acceptLanguage();
211
public Optional<String> platform();
212
}
213
214
/**
215
* Username and password credentials
216
*/
217
public class UsernameAndPassword {
218
public String username();
219
public String password();
220
}
221
```