1 /*
2 * Copyright (c) 2002-2025 Gargoyle Software Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 * https://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 package org.htmlunit;
16
17 import java.io.File;
18 import java.io.IOException;
19 import java.io.InputStream;
20 import java.io.Serializable;
21 import java.net.InetAddress;
22 import java.net.URL;
23 import java.security.KeyStore;
24 import java.security.KeyStoreException;
25 import java.security.NoSuchAlgorithmException;
26 import java.security.cert.CertificateException;
27
28 import javax.net.ssl.SSLContext;
29
30 import org.apache.commons.io.FileUtils;
31
32 /**
33 * Represents options of a {@link WebClient}.
34 *
35 * @author Ahmed Ashour
36 * @author Marc Guillemot
37 * @author Madis Pärn
38 * @author Ronald Brill
39 */
40 @SuppressWarnings("PMD.TooManyFields")
41 public class WebClientOptions implements Serializable {
42
43 /** 1920. */
44 private static final int DEFAULT_SCRREN_WIDTH = 1920;
45 /** 1080. */
46 private static final int DEFAULT_SCRREN_HEIGHT = 1080;
47
48 private boolean javaScriptEnabled_ = true;
49 private boolean cssEnabled_ = true;
50 private boolean printContentOnFailingStatusCode_ = true;
51 private boolean throwExceptionOnFailingStatusCode_ = true;
52 private boolean throwExceptionOnScriptError_ = true;
53 private boolean popupBlockerEnabled_;
54 private boolean isRedirectEnabled_ = true;
55 private File tempFileDirectory_;
56
57 private transient KeyStore sslClientCertificateStore_;
58 private char[] sslClientCertificatePassword_;
59 private transient KeyStore sslTrustStore_;
60 private String[] sslClientProtocols_;
61 private String[] sslClientCipherSuites_;
62
63 private transient SSLContext sslContext_;
64 private boolean useInsecureSSL_; // default is secure SSL
65 private String sslInsecureProtocol_;
66
67 private boolean doNotTrackEnabled_;
68 private String homePage_ = "https://www.htmlunit.org/";
69 private ProxyConfig proxyConfig_;
70 private int timeout_ = 90_000; // like Firefox 16 default's value for network.http.connection-timeout
71 private long connectionTimeToLive_ = -1; // HttpClient default
72
73 private boolean fileProtocolForXMLHttpRequestsAllowed_;
74
75 private int maxInMemory_ = 500 * 1024;
76 private int historySizeLimit_ = 50;
77 private int historyPageCacheLimit_ = Integer.MAX_VALUE;
78 private InetAddress localAddress_;
79 private boolean downloadImages_;
80 private int screenWidth_ = DEFAULT_SCRREN_WIDTH;
81 private int screenHeight_ = DEFAULT_SCRREN_HEIGHT;
82
83 private boolean geolocationEnabled_;
84 private Geolocation geolocation_;
85
86 private int nekoReaderBufferSize_ = -1;
87
88 private boolean webSocketEnabled_ = true;
89 private int webSocketMaxTextMessageSize_ = -1;
90 private int webSocketMaxTextMessageBufferSize_ = -1;
91 private int webSocketMaxBinaryMessageSize_ = -1;
92 private int webSocketMaxBinaryMessageBufferSize_ = -1;
93
94 private boolean isFetchPolyfillEnabled_;
95
96 /**
97 * Sets the SSLContext; if this is set it is used and some other settings are ignored
98 * (protocol, keyStore, keyStorePassword, trustStore, sslClientCertificateStore, sslClientCertificatePassword).
99 * <p>This property is transient (because SSLContext is not serializable)
100 * @param sslContext the SSLContext, {@code null} to use for default value
101 */
102 public void setSSLContext(final SSLContext sslContext) {
103 sslContext_ = sslContext;
104 }
105
106 /**
107 * Gets the SSLContext; if this is set this is used and some other settings are ignored
108 * (protocol, keyStore, keyStorePassword, trustStore, sslClientCertificateStore, sslClientCertificatePassword).
109 * <p>This property is transient (because SSLContext is not serializable)
110 * @return the SSLContext
111 */
112 public SSLContext getSSLContext() {
113 return sslContext_;
114 }
115
116 /**
117 * If set to {@code true}, the client will accept connections to any host, regardless of
118 * whether they have valid certificates or not. This is especially useful when you are trying to
119 * connect to a server with expired or corrupt certificates.
120 * @param useInsecureSSL whether or not to use insecure SSL
121 */
122 public void setUseInsecureSSL(final boolean useInsecureSSL) {
123 useInsecureSSL_ = useInsecureSSL;
124 }
125
126 /**
127 * Indicates if insecure SSL should be used.
128 * @return {@code true} if insecure SSL should be used. Default is {@code false}.
129 */
130 public boolean isUseInsecureSSL() {
131 return useInsecureSSL_;
132 }
133
134 /**
135 * Sets whether or not redirections will be followed automatically on receipt of a redirect
136 * status code from the server.
137 * @param enabled true to enable automatic redirection
138 */
139 public void setRedirectEnabled(final boolean enabled) {
140 isRedirectEnabled_ = enabled;
141 }
142
143 /**
144 * Returns the directory to be used for storing the response content in
145 * a temporary file see {@link #getMaxInMemory()}.
146 * @return the directory to be used for storing temp files or null to use the system default
147 */
148 public File getTempFileDirectory() {
149 return tempFileDirectory_;
150 }
151
152 /**
153 * Sets the directory to be used for storing the response content in
154 * a temporary file see {@link #setMaxInMemory(int)}.
155 * If the given directory does not exist, this creates it.
156 *
157 * @param tempFileDirectory the directory to be used or null to use the system default
158 * @throws IOException in case of error
159 */
160 public void setTempFileDirectory(final File tempFileDirectory) throws IOException {
161 if (tempFileDirectory != null) {
162 if (tempFileDirectory.exists() && !tempFileDirectory.isDirectory()) {
163 throw new IllegalArgumentException("The provided file '" + tempFileDirectory
164 + "' points to an already existing file");
165 }
166
167 if (!tempFileDirectory.exists()) {
168 FileUtils.forceMkdir(tempFileDirectory);
169 }
170 }
171 tempFileDirectory_ = tempFileDirectory;
172 }
173
174 /**
175 * Returns whether or not redirections will be followed automatically on receipt of
176 * a redirect status code from the server.
177 * @return true if automatic redirection is enabled
178 */
179 public boolean isRedirectEnabled() {
180 return isRedirectEnabled_;
181 }
182
183 /**
184 * Sets the SSL client certificate {@link KeyStore} to use.
185 * <p>
186 * If the web server requires Renegotiation, you have to set system property
187 * "sun.security.ssl.allowUnsafeRenegotiation" to true, as hinted in
188 * <a href="http://www.oracle.com/technetwork/java/javase/documentation/tlsreadme2-176330.html">
189 * TLS Renegotiation Issue</a>.
190 * <p>
191 * In some cases the impl seems to pick old certificates from the {@link KeyStore}. To avoid
192 * that, wrap your {@link KeyStore} inside your own {@link KeyStore} impl and filter out outdated
193 * certificates.
194 * <p>This property is transient (because KeyStore is not serializable)
195 *
196 * @param keyStore {@link KeyStore} to use
197 * @param keyStorePassword the keystore password
198 */
199 public void setSSLClientCertificateKeyStore(final KeyStore keyStore, final char[] keyStorePassword) {
200 sslClientCertificateStore_ = keyStore;
201 sslClientCertificatePassword_ = keyStorePassword;
202 }
203
204 /**
205 * Sets the SSL client certificate to use.
206 * The needed parameters are used to construct a {@link java.security.KeyStore}.
207 * <p>
208 * If the web server requires Renegotiation, you have to set system property
209 * "sun.security.ssl.allowUnsafeRenegotiation" to true, as hinted in
210 * <a href="http://www.oracle.com/technetwork/java/javase/documentation/tlsreadme2-176330.html">
211 * TLS Renegotiation Issue</a>.
212 * <p>This property is transient (because KeyStore is not serializable)
213 *
214 * @param keyStoreUrl the URL which locates the certificate {@link KeyStore}
215 * @param keyStorePassword the certificate {@link KeyStore} password
216 * @param keyStoreType the type of certificate {@link KeyStore}, usually {@code jks} or {@code pkcs12}
217 *
218 */
219 public void setSSLClientCertificateKeyStore(final URL keyStoreUrl, final String keyStorePassword,
220 final String keyStoreType) {
221 try (InputStream is = keyStoreUrl.openStream()) {
222 sslClientCertificateStore_ = getKeyStore(is, keyStorePassword, keyStoreType);
223 sslClientCertificatePassword_ = keyStorePassword == null ? null : keyStorePassword.toCharArray();
224 }
225 catch (final Exception e) {
226 throw new RuntimeException(e);
227 }
228 }
229
230 /**
231 * Sets the SSL client certificate {@link KeyStore} to use. The parameters are used to
232 * construct the {@link KeyStore}.
233 * <p>
234 * If the web server requires Renegotiation, you have to set system property
235 * "sun.security.ssl.allowUnsafeRenegotiation" to true, as hinted in
236 * <a href="http://www.oracle.com/technetwork/java/javase/documentation/tlsreadme2-176330.html">
237 * TLS Renegotiation Issue</a>.
238 * <p>
239 * In some cases the impl seems to pick old certificates from the {@link KeyStore}. To avoid
240 * that, wrap your {@link KeyStore} inside your own {@link KeyStore} impl and filter out outdated
241 * certificates. Provide the {@link KeyStore} to the options instead of the input stream.
242 *
243 * @param keyStoreInputStream the input stream which represents the {@link KeyStore} holding the certificates
244 * @param keyStorePassword the {@link KeyStore} password
245 * @param keyStoreType the type of {@link KeyStore}, usually {@code jks} or {@code pkcs12}
246 */
247 public void setSSLClientCertificateKeyStore(final InputStream keyStoreInputStream,
248 final String keyStorePassword, final String keyStoreType) {
249 try {
250 setSSLClientCertificateKeyStore(
251 getKeyStore(keyStoreInputStream, keyStorePassword, keyStoreType),
252 keyStorePassword.toCharArray());
253 }
254 catch (final Exception e) {
255 throw new RuntimeException(e);
256 }
257 }
258
259 /**
260 * Gets the SSLClientCertificateStore.
261 * <p>This property is transient (because KeyStore is not serializable)
262 *
263 * @return the KeyStore for use on SSL connections
264 */
265 public KeyStore getSSLClientCertificateStore() {
266 return sslClientCertificateStore_;
267 }
268
269 /**
270 * Gets the SSLClientCertificatePassword.
271 * @return the password
272 */
273 public char[] getSSLClientCertificatePassword() {
274 return sslClientCertificatePassword_;
275 }
276
277 /**
278 * Gets the protocol versions enabled for use on SSL connections.
279 * @return the protocol versions enabled for use on SSL connections
280 * @see #setSSLClientProtocols(String...)
281 */
282 public String[] getSSLClientProtocols() {
283 return sslClientProtocols_;
284 }
285
286 /**
287 * Sets the protocol versions enabled for use on SSL connections,
288 * {@code null} to use default ones.
289 *
290 * @param sslClientProtocols the protocol versions
291 * @see javax.net.ssl.SSLSocket#setEnabledProtocols(String[])
292 * @see #getSSLClientProtocols()
293 */
294 public void setSSLClientProtocols(final String... sslClientProtocols) {
295 sslClientProtocols_ = sslClientProtocols;
296 }
297
298 /**
299 * Gets the cipher suites enabled for use on SSL connections.
300 * @return the cipher suites enabled for use on SSL connections
301 * @see #setSSLClientCipherSuites(String...)
302 */
303 public String[] getSSLClientCipherSuites() {
304 return sslClientCipherSuites_;
305 }
306
307 /**
308 * Sets the cipher suites enabled for use on SSL connections,
309 * {@code null} to use default ones.
310 *
311 * @param sslClientCipherSuites the cipher suites
312 * @see javax.net.ssl.SSLSocket#setEnabledCipherSuites(String[])
313 * @see #getSSLClientCipherSuites()
314 */
315 public void setSSLClientCipherSuites(final String... sslClientCipherSuites) {
316 sslClientCipherSuites_ = sslClientCipherSuites;
317 }
318
319 /**
320 * Enables/disables JavaScript support. By default, this property is enabled.
321 *
322 * @param enabled {@code true} to enable JavaScript support
323 */
324 public void setJavaScriptEnabled(final boolean enabled) {
325 javaScriptEnabled_ = enabled;
326 }
327
328 /**
329 * Returns {@code true} if JavaScript is enabled and the script engine was loaded successfully.
330 *
331 * @return {@code true} if JavaScript is enabled
332 */
333 public boolean isJavaScriptEnabled() {
334 return javaScriptEnabled_;
335 }
336
337 /**
338 * Enables/disables CSS support. By default, this property is enabled.
339 * If disabled HtmlUnit will not download the linked css files and also
340 * not triggered the associated onload/onerror events.
341 *
342 * @param enabled {@code true} to enable CSS support
343 */
344 public void setCssEnabled(final boolean enabled) {
345 cssEnabled_ = enabled;
346 }
347
348 /**
349 * Returns {@code true} if CSS is enabled.
350 *
351 * @return {@code true} if CSS is enabled
352 */
353 public boolean isCssEnabled() {
354 return cssEnabled_;
355 }
356
357 /**
358 * Enable/disable the popup window blocker. By default, the popup blocker is disabled, and popup
359 * windows are allowed. When set to {@code true}, <code>window.open()</code> has no effect and
360 * returns {@code null}.
361 *
362 * @param enabled {@code true} to enable the popup window blocker
363 */
364 public void setPopupBlockerEnabled(final boolean enabled) {
365 popupBlockerEnabled_ = enabled;
366 }
367
368 /**
369 * Returns {@code true} if the popup window blocker is enabled.
370 *
371 * @return {@code true} if the popup window blocker is enabled
372 */
373 public boolean isPopupBlockerEnabled() {
374 return popupBlockerEnabled_;
375 }
376
377 /**
378 * Enables/disables "Do Not Track" support. By default, this property is disabled.
379 *
380 * @param enabled {@code true} to enable "Do Not Track" support
381 */
382 public void setDoNotTrackEnabled(final boolean enabled) {
383 doNotTrackEnabled_ = enabled;
384 }
385
386 /**
387 * Returns {@code true} if "Do Not Track" is enabled.
388 *
389 * @return {@code true} if "Do Not Track" is enabled
390 */
391 public boolean isDoNotTrackEnabled() {
392 return doNotTrackEnabled_;
393 }
394
395 /**
396 * Specify whether or not the content of the resulting document will be
397 * printed to the console in the event of a failing response code.
398 * Successful response codes are in the range 200-299. The default is true.
399 *
400 * @param enabled True to enable this feature
401 */
402 public void setPrintContentOnFailingStatusCode(final boolean enabled) {
403 printContentOnFailingStatusCode_ = enabled;
404 }
405
406 /**
407 * Returns {@code true} if the content of the resulting document will be printed to
408 * the console in the event of a failing response code.
409 *
410 * @return {@code true} if the content of the resulting document will be printed to
411 * the console in the event of a failing response code
412 * @see #setPrintContentOnFailingStatusCode
413 */
414 public boolean isPrintContentOnFailingStatusCode() {
415 return printContentOnFailingStatusCode_;
416 }
417
418 /**
419 * Specify whether or not an exception will be thrown in the event of a
420 * failing status code. Successful status codes are in the range 200-299.
421 * The default is true.
422 *
423 * @param enabled {@code true} to enable this feature
424 */
425 public void setThrowExceptionOnFailingStatusCode(final boolean enabled) {
426 throwExceptionOnFailingStatusCode_ = enabled;
427 }
428
429 /**
430 * Returns {@code true} if an exception will be thrown in the event of a failing response code.
431 * @return {@code true} if an exception will be thrown in the event of a failing response code
432 * @see #setThrowExceptionOnFailingStatusCode
433 */
434 public boolean isThrowExceptionOnFailingStatusCode() {
435 return throwExceptionOnFailingStatusCode_;
436 }
437
438 /**
439 * Indicates if an exception should be thrown when a script execution fails
440 * (the default) or if it should be caught and just logged to allow page
441 * execution to continue.
442 * @return {@code true} if an exception is thrown on script error (the default)
443 */
444 public boolean isThrowExceptionOnScriptError() {
445 return throwExceptionOnScriptError_;
446 }
447
448 /**
449 * Changes the behavior of this webclient when a script error occurs.
450 * @param enabled indicates if exception should be thrown or not
451 */
452 public void setThrowExceptionOnScriptError(final boolean enabled) {
453 throwExceptionOnScriptError_ = enabled;
454 }
455
456 /**
457 * Returns the client's current homepage.
458 * @return the client's current homepage
459 */
460 public String getHomePage() {
461 return homePage_;
462 }
463
464 /**
465 * Sets the client's homepage.
466 * @param homePage the new homepage URL
467 */
468 public void setHomePage(final String homePage) {
469 homePage_ = homePage;
470 }
471
472 /**
473 * Returns the proxy configuration for this client.
474 * @return the proxy configuration for this client
475 */
476 public ProxyConfig getProxyConfig() {
477 return proxyConfig_;
478 }
479
480 /**
481 * Sets the proxy configuration for this client.
482 * @param proxyConfig the proxy configuration for this client
483 */
484 public void setProxyConfig(final ProxyConfig proxyConfig) {
485 WebAssert.notNull("proxyConfig", proxyConfig);
486 proxyConfig_ = proxyConfig;
487 }
488
489 /**
490 * Gets the timeout value for the {@link WebConnection}.
491 * The default timeout is 90 seconds.
492 * @return the timeout value in milliseconds
493 * @see WebClientOptions#setTimeout(int)
494 */
495 public int getTimeout() {
496 return timeout_;
497 }
498
499 /**
500 * <p>Sets the timeout of the {@link WebConnection}. Set to zero for an infinite wait.</p>
501 *
502 * <p>Note: The timeout is used twice. The first is for making the socket connection, the second is
503 * for data retrieval. If the time is critical you must allow for twice the time specified here.</p>
504 *
505 * @param timeout the value of the timeout in milliseconds
506 */
507 public void setTimeout(final int timeout) {
508 timeout_ = timeout;
509 }
510
511 /**
512 * Gets the connTimeToLive value for the HttpClient connection pool.
513 *
514 * @return the timeout value in milliseconds
515 */
516 public long getConnectionTimeToLive() {
517 return connectionTimeToLive_;
518 }
519
520 /**
521 * Sets the connTimeToLive of the HttpClient connection pool.
522 * Use this if you are working with web pages behind a DNS based load balancer.
523 * Set to -1 (default) for disabling this timeout.
524 *
525 * @param connectionTimeToLive the value of the timeout in milliseconds
526 */
527 public void setConnectionTimeToLive(final long connectionTimeToLive) {
528 connectionTimeToLive_ = connectionTimeToLive;
529 }
530
531 /**
532 * Sets the SSL protocol, used only when {@link #setUseInsecureSSL(boolean)} is set to {@code true}.
533 * @param sslInsecureProtocol the SSL protocol for insecure SSL connections,
534 * {@code null} to use for default value
535 */
536 public void setSSLInsecureProtocol(final String sslInsecureProtocol) {
537 sslInsecureProtocol_ = sslInsecureProtocol;
538 }
539
540 /**
541 * Gets the SSL protocol, to be used only when {@link #setUseInsecureSSL(boolean)} is set to {@code true}.
542 * @return the SSL protocol for insecure SSL connections
543 */
544 public String getSSLInsecureProtocol() {
545 return sslInsecureProtocol_;
546 }
547
548 /**
549 * Sets the SSL server certificate trust store. All server certificates will be validated against
550 * this trust store.
551 * <p>This property is transient (because KeyStore is not serializable)
552 * <p>The needed parameters are used to construct a {@link java.security.KeyStore}.
553 *
554 * @param sslTrustStoreUrl the URL which locates the trust store
555 * @param sslTrustStorePassword the trust store password
556 * @param sslTrustStoreType the type of trust store, usually {@code jks} or {@code pkcs12}
557 */
558 public void setSSLTrustStore(final URL sslTrustStoreUrl, final String sslTrustStorePassword,
559 final String sslTrustStoreType) {
560 try (InputStream is = sslTrustStoreUrl.openStream()) {
561 sslTrustStore_ = getKeyStore(is, sslTrustStorePassword, sslTrustStoreType);
562 }
563 catch (final Exception e) {
564 throw new RuntimeException(e);
565 }
566 }
567
568 void setSSLTrustStore(final KeyStore keyStore) {
569 sslTrustStore_ = keyStore;
570 }
571
572 /**
573 * Gets the SSL TrustStore.
574 * <p>This property is transient (because KeyStore is not serializable)
575 * @return the SSL TrustStore for insecure SSL connections
576 */
577 public KeyStore getSSLTrustStore() {
578 return sslTrustStore_;
579 }
580
581 private static KeyStore getKeyStore(final InputStream inputStream, final String keystorePassword,
582 final String keystoreType)
583 throws IOException, KeyStoreException, NoSuchAlgorithmException, CertificateException {
584 if (inputStream == null) {
585 return null;
586 }
587
588 final KeyStore keyStore = KeyStore.getInstance(keystoreType);
589 final char[] passwordChars = keystorePassword == null ? null : keystorePassword.toCharArray();
590 keyStore.load(inputStream, passwordChars);
591 return keyStore;
592 }
593
594 /**
595 * Returns the maximum bytes to have in memory, after which the content is saved to a temporary file.
596 * Default is 500 * 1024.
597 * @return the maximum bytes in memory
598 */
599 public int getMaxInMemory() {
600 return maxInMemory_;
601 }
602
603 /**
604 * Sets the maximum bytes to have in memory, after which the content is saved to a temporary file.
605 * Set this to zero or -1 to deactivate the saving at all.
606 * @param maxInMemory maximum bytes in memory
607 */
608 public void setMaxInMemory(final int maxInMemory) {
609 maxInMemory_ = maxInMemory;
610 }
611
612 /**
613 * Returns the maximum number of {@link Page pages} kept in {@link WebWindow#getHistory()}.
614 * @return the maximum number of pages in history
615 */
616 public int getHistorySizeLimit() {
617 return historySizeLimit_;
618 }
619
620 /**
621 * Sets the History size limit. HtmlUnit uses SoftReferences<Page> for
622 * storing the pages that are part of the history. If you like to fine tune this
623 * you can use {@link #setHistoryPageCacheLimit(int)} to limit the number of page references
624 * stored by the history.
625 * @param historySizeLimit maximum number of pages in history
626 */
627 public void setHistorySizeLimit(final int historySizeLimit) {
628 historySizeLimit_ = historySizeLimit;
629 }
630
631 /**
632 * Returns the maximum number of {@link Page pages} to cache in history.
633 * @return the maximum number of pages to cache in history
634 */
635 public int getHistoryPageCacheLimit() {
636 return historyPageCacheLimit_;
637 }
638
639 /**
640 * Sets the maximum number of {@link Page pages} to cache in history.
641 * If this value is smaller than the {{@link #getHistorySizeLimit()} than
642 * HtmlUnit will only use soft references for the first historyPageCacheLimit
643 * entries in the history. For older entries only the url is saved; the page
644 * will be (re)retrieved on demand.
645 * @param historyPageCacheLimit maximum number of pages to cache in history
646 * default is Integer.MAX_VALUE; negative values are having the same effect
647 * as setting this to zero.
648 */
649 public void setHistoryPageCacheLimit(final int historyPageCacheLimit) {
650 historyPageCacheLimit_ = historyPageCacheLimit;
651 }
652
653 /**
654 * Returns local address to be used for request execution.
655 * <p>
656 * On machines with multiple network interfaces, this parameter can be used to select the network interface
657 * from which the connection originates.
658 * <p>
659 * Default: {@code null}
660 *
661 * @return the local address
662 */
663 public InetAddress getLocalAddress() {
664 return localAddress_;
665 }
666
667 /**
668 * Sets the local address to be used for request execution.
669 * <p>
670 * On machines with multiple network interfaces, this parameter can be used to select the network interface
671 * from which the connection originates.
672 *
673 * @param localAddress the local address
674 */
675 public void setLocalAddress(final InetAddress localAddress) {
676 localAddress_ = localAddress;
677 }
678
679 /**
680 * Sets whether to automatically download images by default, or not.
681 * @param downloadImages whether to automatically download images by default, or not
682 */
683 public void setDownloadImages(final boolean downloadImages) {
684 downloadImages_ = downloadImages;
685 }
686
687 /**
688 * Returns whether to automatically download images by default, or not.
689 * @return whether to automatically download images by default, or not.
690 */
691 public boolean isDownloadImages() {
692 return downloadImages_;
693 }
694
695 /**
696 * Sets the screen width.
697 *
698 * @param screenWidth the screen width
699 */
700 public void setScreenWidth(final int screenWidth) {
701 screenWidth_ = screenWidth;
702 }
703
704 /**
705 * Returns the screen width.
706 *
707 * @return the screen width
708 */
709 public int getScreenWidth() {
710 return screenWidth_;
711 }
712
713 /**
714 * Sets the screen height.
715 *
716 * @param screenHeight the screen height
717 */
718 public void setScreenHeight(final int screenHeight) {
719 screenHeight_ = screenHeight;
720 }
721
722 /**
723 * Returns the screen height.
724 *
725 * @return the screen height
726 */
727 public int getScreenHeight() {
728 return screenHeight_;
729 }
730
731 /**
732 * @return the Neko Html parser reader buffer size
733 */
734 public int getNekoReaderBufferSize() {
735 return nekoReaderBufferSize_;
736 }
737
738 /**
739 * Sets the Neko Html parser reader buffer size.
740 *
741 * @param nekoReaderBufferSize the new value
742 */
743 public void setNekoReaderBufferSize(final int nekoReaderBufferSize) {
744 nekoReaderBufferSize_ = nekoReaderBufferSize;
745 }
746
747 /**
748 * Enables/disables WebSocket support. By default, this property is enabled.
749 *
750 * @param enabled {@code true} to enable WebSocket support
751 */
752 public void setWebSocketEnabled(final boolean enabled) {
753 webSocketEnabled_ = enabled;
754 }
755
756 /**
757 * Returns {@code true} if WebSockets are enabled.
758 *
759 * @return {@code true} if WebSockets are enabled
760 */
761 public boolean isWebSocketEnabled() {
762 return webSocketEnabled_;
763 }
764
765 /**
766 * @return the WebSocket maxTextMessageSize
767 */
768 public int getWebSocketMaxTextMessageSize() {
769 return webSocketMaxTextMessageSize_;
770 }
771
772 /**
773 * Sets the WebSocket maxTextMessageSize.
774 *
775 * @param webSocketMaxTextMessageSize the new value
776 */
777 public void setWebSocketMaxTextMessageSize(final int webSocketMaxTextMessageSize) {
778 webSocketMaxTextMessageSize_ = webSocketMaxTextMessageSize;
779 }
780
781 /**
782 * @return the WebSocket maxTextMessageBufferSize
783 */
784 public int getWebSocketMaxTextMessageBufferSize() {
785 return webSocketMaxTextMessageBufferSize_;
786 }
787
788 /**
789 * Sets the WebSocket maxTextMessageBufferSize.
790 *
791 * @param webSocketMaxTextMessageBufferSize the new value
792 */
793 public void setWebSocketMaxTextMessageBufferSize(final int webSocketMaxTextMessageBufferSize) {
794 webSocketMaxTextMessageBufferSize_ = webSocketMaxTextMessageBufferSize;
795 }
796
797 /**
798 * @return the WebSocket maxTextMessageSize
799 */
800 public int getWebSocketMaxBinaryMessageSize() {
801 return webSocketMaxBinaryMessageSize_;
802 }
803
804 /**
805 * Sets the WebSocket maxBinaryMessageSize.
806 *
807 * @param webSocketMaxBinaryMessageSize the new value
808 */
809 public void setWebSocketMaxBinaryMessageSize(final int webSocketMaxBinaryMessageSize) {
810 webSocketMaxBinaryMessageSize_ = webSocketMaxBinaryMessageSize;
811 }
812
813 /**
814 * @return the WebSocket maxBinaryMessageBufferSize
815 */
816 public int getWebSocketMaxBinaryMessageBufferSize() {
817 return webSocketMaxBinaryMessageBufferSize_;
818 }
819
820 /**
821 * Sets the WebSocket maxBinaryMessageBufferSize.
822 *
823 * @param webSocketMaxBinaryMessageBufferSize the new value
824 */
825 public void setWebSocketMaxBinaryMessageBufferSize(final int webSocketMaxBinaryMessageBufferSize) {
826 webSocketMaxBinaryMessageBufferSize_ = webSocketMaxBinaryMessageBufferSize;
827 }
828
829 /**
830 * Sets whether or not fetch polyfill should be used.
831 * @param enabled true to enable fetch polyfill
832 */
833 public void setFetchPolyfillEnabled(final boolean enabled) {
834 isFetchPolyfillEnabled_ = enabled;
835 }
836
837 /**
838 * @return true if the fetch api polyfill is enabled
839 */
840 public boolean isFetchPolyfillEnabled() {
841 return isFetchPolyfillEnabled_;
842 }
843
844 /**
845 * Enables/disables Geolocation support. By default, this property is disabled.
846 *
847 * @param enabled {@code true} to enable Geolocation support
848 */
849 public void setGeolocationEnabled(final boolean enabled) {
850 geolocationEnabled_ = enabled;
851 }
852
853 /**
854 * @return {@code true} if Geolocation is enabled
855 */
856 public boolean isGeolocationEnabled() {
857 return geolocationEnabled_;
858 }
859
860 /**
861 * @return the {@link Geolocation}
862 */
863 public Geolocation getGeolocation() {
864 return geolocation_;
865 }
866
867 /**
868 * Sets the {@link Geolocation} to be used.
869 * @param geolocation the new location or null
870 */
871 public void setGeolocation(final Geolocation geolocation) {
872 geolocation_ = geolocation;
873 }
874
875 /**
876 * Support class for Geolocation.
877 */
878 public static class Geolocation implements Serializable {
879 private final double accuracy_;
880 private final double latitude_;
881 private final double longitude_;
882 private final Double altitude_;
883 private final Double altitudeAccuracy_;
884 private final Double heading_;
885 private final Double speed_;
886
887 /**
888 * Ctor.
889 *
890 * @param accuracy the accuracy
891 * @param latitude the latitude
892 * @param longitude the longitude
893 * @param altitude the altitude or null
894 * @param altitudeAccuracy the altitudeAccuracy or null
895 * @param heading the heading or null
896 * @param speed the speed or null
897 */
898 public Geolocation(
899 final double latitude,
900 final double longitude,
901 final double accuracy,
902 final Double altitude,
903 final Double altitudeAccuracy,
904 final Double heading,
905 final Double speed) {
906 latitude_ = latitude;
907 longitude_ = longitude;
908 accuracy_ = accuracy;
909 altitude_ = altitude;
910 altitudeAccuracy_ = altitudeAccuracy;
911 heading_ = heading;
912 speed_ = speed;
913 }
914
915 /**
916 * @return the accuracy
917 */
918 public double getAccuracy() {
919 return accuracy_;
920 }
921
922 /**
923 * @return the latitude
924 */
925 public double getLatitude() {
926 return latitude_;
927 }
928
929 /**
930 * @return the longitude
931 */
932 public double getLongitude() {
933 return longitude_;
934 }
935
936 /**
937 * @return the longitude
938 */
939 public Double getAltitude() {
940 return altitude_;
941 }
942
943 /**
944 * @return the altitudeAccuracy
945 */
946 public Double getAltitudeAccuracy() {
947 return altitudeAccuracy_;
948 }
949
950 /**
951 * @return the heading
952 */
953 public Double getHeading() {
954 return heading_;
955 }
956
957 /**
958 * @return the speed
959 */
960 public Double getSpeed() {
961 return speed_;
962 }
963 }
964
965 /**
966 * If set to {@code true}, the client will accept XMLHttpRequests to URL's
967 * using the 'file' protocol. Allowing this introduces security problems and is
968 * therefore not allowed by current browsers. But some browsers have special settings
969 * to open this door; therefore we have this option.
970 * @param fileProtocolForXMLHttpRequestsAllowed whether or not allow (local) file access
971 */
972 public void setFileProtocolForXMLHttpRequestsAllowed(final boolean fileProtocolForXMLHttpRequestsAllowed) {
973 fileProtocolForXMLHttpRequestsAllowed_ = fileProtocolForXMLHttpRequestsAllowed;
974 }
975
976 /**
977 * Indicates if the client will accept XMLHttpRequests to URL's
978 * using the 'file' protocol.
979 * @return {@code true} if access to local files is allowed.
980 */
981 public boolean isFileProtocolForXMLHttpRequestsAllowed() {
982 return fileProtocolForXMLHttpRequestsAllowed_;
983 }
984 }