| 1 |
import json |
| 2 |
import logging |
| 3 |
from http.cookies import SimpleCookie |
| 4 |
from threading import Semaphore |
| 5 |
from urllib.parse import urlparse |
| 6 |
|
| 7 |
from android.activity import _activity as activity # noqa |
| 8 |
from android.runnable import run_on_ui_thread # noqa |
| 9 |
from jnius import autoclass, cast |
| 10 |
|
| 11 |
from webview import _state, settings |
| 12 |
from webview.models import Request, Response |
| 13 |
from webview.platforms.android.app import App |
| 14 |
from webview.platforms.android.jclass import ( |
| 15 |
AlertDialogBuilder, |
| 16 |
Context, |
| 17 |
CookieManager, |
| 18 |
DownloadManagerRequest, |
| 19 |
Environment, |
| 20 |
KeyEvent, |
| 21 |
PyJavascriptInterface, |
| 22 |
PyWebChromeClient, |
| 23 |
PyWebViewClient, |
| 24 |
Uri, |
| 25 |
View, |
| 26 |
WebView, |
| 27 |
) |
| 28 |
from webview.platforms.android.jinterface import ( |
| 29 |
DownloadListener, |
| 30 |
EventCallbackWrapper, |
| 31 |
JsApiCallbackWrapper, |
| 32 |
KeyListener, |
| 33 |
RequestInterceptor, |
| 34 |
ValueCallback, |
| 35 |
) |
| 36 |
from webview.util import create_cookie, inject_pywebview, js_bridge_call |
| 37 |
|
| 38 |
logger = logging.getLogger('pywebview') |
| 39 |
|
| 40 |
renderer = 'android-webkit' |
| 41 |
app = None |
| 42 |
|
| 43 |
|
| 44 |
class BrowserView: |
| 45 |
def __init__(self, window): |
| 46 |
self.pywebview_window = window |
| 47 |
self.webview = None |
| 48 |
self.dialog = None |
| 49 |
self.pywebview_window.native = self |
| 50 |
self.is_fullscreen = False |
| 51 |
self.create_webview() |
| 52 |
|
| 53 |
@run_on_ui_thread |
| 54 |
def create_webview(self): |
| 55 |
def js_api_handler(func, params, id): |
| 56 |
js_bridge_call(self.pywebview_window, func, json.loads(params), id) |
| 57 |
|
| 58 |
def chrome_callback(event, data): |
| 59 |
print(event, data) |
| 60 |
|
| 61 |
def webview_callback(event, data): |
| 62 |
if event == 'onPageFinished': |
| 63 |
|
| 64 |
@run_on_ui_thread |
| 65 |
def _handle_page_finished(): |
| 66 |
try: |
| 67 |
inject_pywebview(renderer, self.pywebview_window) |
| 68 |
# Get fresh CookieManager reference to avoid stale Java object references |
| 69 |
cookie_manager = CookieManager.getInstance() |
| 70 |
if not _state['private_mode']: |
| 71 |
cookie_manager.setAcceptCookie(True) |
| 72 |
cookie_manager.acceptCookie() |
| 73 |
cookie_manager.flush() |
| 74 |
else: |
| 75 |
cookie_manager.setAcceptCookie(False) |
| 76 |
except Exception as e: |
| 77 |
logger.error(f'Error handling page finished: {e}') |
| 78 |
|
| 79 |
_handle_page_finished() |
| 80 |
|
| 81 |
elif event == 'onCookiesReceived': |
| 82 |
try: |
| 83 |
cookie_data = json.loads(data) if data else {} |
| 84 |
# url = cookie_data.get('url', '') |
| 85 |
cookies = cookie_data.get('cookies', []) |
| 86 |
for cookie_string in cookies: |
| 87 |
cookie = SimpleCookie() |
| 88 |
cookie.load(cookie_string) |
| 89 |
app.view._cookies.append(cookie) |
| 90 |
|
| 91 |
except Exception as e: |
| 92 |
logger.error(f'Error parsing cookies: {e}') |
| 93 |
|
| 94 |
elif event == 'onReceivedHttpError': |
| 95 |
response_data = json.loads(data) |
| 96 |
response = Response( |
| 97 |
response_data.get('url', ''), |
| 98 |
response_data.get('statusCode', 0), |
| 99 |
response_data.get('headers', {}), |
| 100 |
) |
| 101 |
self.pywebview_window.events.response_received.set(response) |
| 102 |
|
| 103 |
self._cookies = [] |
| 104 |
self.webview = WebView(activity) |
| 105 |
webview_settings = self.webview.getSettings() |
| 106 |
webview_settings.setAllowFileAccessFromFileURLs(True) |
| 107 |
webview_settings.setJavaScriptEnabled(True) |
| 108 |
webview_settings.setUseWideViewPort(False) |
| 109 |
webview_settings.setLoadWithOverviewMode(True) |
| 110 |
webview_settings.setSupportZoom(self.pywebview_window.zoomable) |
| 111 |
webview_settings.setBuiltInZoomControls(False) |
| 112 |
webview_settings.setDomStorageEnabled(not _state['private_mode']) |
| 113 |
|
| 114 |
if _state['user_agent']: |
| 115 |
webview_settings.setUserAgentString(_state['user_agent']) |
| 116 |
|
| 117 |
self._webview_callback_wrapper = EventCallbackWrapper(webview_callback) |
| 118 |
self._webview_client = webview_client = PyWebViewClient() |
| 119 |
webview_client.setCallback( |
| 120 |
self._webview_callback_wrapper, _state['ssl'] or settings['IGNORE_SSL_ERRORS'] |
| 121 |
) |
| 122 |
self._request_interceptor = RequestInterceptor(self._on_request, self._on_response) |
| 123 |
webview_client.setRequestInterceptor(self._request_interceptor) |
| 124 |
|
| 125 |
self.webview.setWebViewClient(webview_client) |
| 126 |
|
| 127 |
self._chrome_callback_wrapper = EventCallbackWrapper(chrome_callback) |
| 128 |
self._chrome_client = chrome_client = PyWebChromeClient() |
| 129 |
chrome_client.setCallback(self._chrome_callback_wrapper) |
| 130 |
self.webview.setWebChromeClient(chrome_client) |
| 131 |
|
| 132 |
self._js_api_callback_wrapper = JsApiCallbackWrapper(js_api_handler) |
| 133 |
self._js_interface = js_interface = PyJavascriptInterface() |
| 134 |
js_interface.setCallback(self._js_api_callback_wrapper) |
| 135 |
self.webview.addJavascriptInterface(js_interface, 'external') |
| 136 |
|
| 137 |
if settings['ALLOW_DOWNLOADS']: |
| 138 |
|
| 139 |
def _on_download_start(url, *_): |
| 140 |
context = activity.getApplicationContext() |
| 141 |
visibility = DownloadManagerRequest.VISIBILITY_VISIBLE_NOTIFY_COMPLETED |
| 142 |
dir_type = Environment.DIRECTORY_DOWNLOADS |
| 143 |
uri = Uri.parse(url) |
| 144 |
filepath = uri.getLastPathSegment() |
| 145 |
request = DownloadManagerRequest(uri) |
| 146 |
request.setNotificationVisibility(visibility) |
| 147 |
request.setDestinationInExternalFilesDir(context, dir_type, filepath) |
| 148 |
dm = cast( |
| 149 |
'android.app.DownloadManager', |
| 150 |
activity.getSystemService(Context.DOWNLOAD_SERVICE), |
| 151 |
) |
| 152 |
dm.enqueue(request) |
| 153 |
|
| 154 |
self._download_listener = DownloadListener(_on_download_start) |
| 155 |
self.webview.setDownloadListener(self._download_listener) |
| 156 |
|
| 157 |
self._key_listener = KeyListener(self._back_pressed) |
| 158 |
self.webview.setOnKeyListener(self._key_listener) |
| 159 |
self.pywebview_window.events.before_show.set() |
| 160 |
|
| 161 |
if self.pywebview_window.real_url: |
| 162 |
self.webview.loadUrl(self.pywebview_window.real_url) |
| 163 |
elif self.pywebview_window.html: |
| 164 |
self.webview.loadDataWithBaseURL( |
| 165 |
None, self.pywebview_window.html, 'text/html', 'UTF-8', None |
| 166 |
) |
| 167 |
|
| 168 |
if self.pywebview_window.fullscreen: |
| 169 |
toggle_fullscreen(self.pywebview_window) |
| 170 |
|
| 171 |
self.pywebview_window.events.shown.set() |
| 172 |
activity.setContentView(self.webview) |
| 173 |
|
| 174 |
def _on_request(self, url: str, method: str, headers_json: str): |
| 175 |
headers = json.loads(headers_json) if headers_json else {} |
| 176 |
original_headers = headers.copy() |
| 177 |
|
| 178 |
request = Request(url, method, headers) |
| 179 |
self.pywebview_window.events.request_sent.set(request) |
| 180 |
|
| 181 |
if request.headers != original_headers: |
| 182 |
logger.debug( |
| 183 |
'Request headers mutated. Original: %s, Mutated: %s', |
| 184 |
original_headers, |
| 185 |
request.headers, |
| 186 |
) |
| 187 |
|
| 188 |
return json.dumps(request.headers) |
| 189 |
|
| 190 |
return None |
| 191 |
|
| 192 |
def _on_response(self, url: str, status_code: int, headers_json: str): |
| 193 |
headers = json.loads(headers_json) if headers_json else {} |
| 194 |
|
| 195 |
response = Response(url, status_code, headers) |
| 196 |
self.pywebview_window.events.response_received.set(response) |
| 197 |
|
| 198 |
def dismiss(self): |
| 199 |
@run_on_ui_thread |
| 200 |
def _dismiss(): |
| 201 |
try: |
| 202 |
if _state['private_mode']: |
| 203 |
self.webview.clearHistory() |
| 204 |
self.webview.clearCache(True) |
| 205 |
self.webview.clearFormData() |
| 206 |
|
| 207 |
if hasattr(self, '_js_interface') and self._js_interface: |
| 208 |
self.webview.removeJavascriptInterface('external') |
| 209 |
self._js_interface = None |
| 210 |
logger.error('Removed JavaScript interface') |
| 211 |
|
| 212 |
if hasattr(self, '_webview_client') and self._webview_client: |
| 213 |
self._webview_client.destroy() |
| 214 |
self._webview_client = None |
| 215 |
|
| 216 |
if hasattr(self, '_webview_callback_wrapper'): |
| 217 |
self._webview_callback_wrapper = None |
| 218 |
if hasattr(self, '_chrome_callback_wrapper'): |
| 219 |
self._chrome_callback_wrapper = None |
| 220 |
|
| 221 |
if hasattr(self, '_js_api_callback_wrapper'): |
| 222 |
self._js_api_callback_wrapper = None |
| 223 |
|
| 224 |
if hasattr(self, '_request_interceptor'): |
| 225 |
self._request_interceptor = None |
| 226 |
self._download_listener = None |
| 227 |
|
| 228 |
if hasattr(self, '_key_listener'): |
| 229 |
self._key_listener = None |
| 230 |
|
| 231 |
self.webview.destroy() |
| 232 |
self.layout = None |
| 233 |
self.webview = None |
| 234 |
except Exception as e: |
| 235 |
logger.error(f'Error during dismiss: {e}') |
| 236 |
finally: |
| 237 |
app.stop() |
| 238 |
|
| 239 |
_dismiss() |
| 240 |
|
| 241 |
def _quit_confirmation(self): |
| 242 |
def cancel(dialog, which): |
| 243 |
self.dialog = None |
| 244 |
|
| 245 |
def quit(dialog, which): |
| 246 |
self.pywebview_window.closed.set() |
| 247 |
self.dialog = None |
| 248 |
app.stop() |
| 249 |
|
| 250 |
if self.dialog: |
| 251 |
return |
| 252 |
|
| 253 |
String = autoclass('java.lang.String') |
| 254 |
message = String(self.pywebview_window.localization['global.quitConfirmation']) |
| 255 |
quit_msg = String(self.pywebview_window.localization['global.quit']) |
| 256 |
cancel_msg = String(self.pywebview_window.localization['global.cancel']) |
| 257 |
|
| 258 |
self.dialog = ( |
| 259 |
AlertDialogBuilder(activity) |
| 260 |
.setMessage(message) |
| 261 |
.setPositiveButton(quit_msg, quit) |
| 262 |
.setNegativeButton(cancel_msg, cancel) |
| 263 |
.setOnCancelListener(cancel) |
| 264 |
.show() |
| 265 |
) |
| 266 |
|
| 267 |
def _back_pressed(self, v, key_code, event): |
| 268 |
if not (event.getAction() == KeyEvent.ACTION_DOWN and key_code == KeyEvent.KEYCODE_BACK): |
| 269 |
return False |
| 270 |
elif self.webview.canGoBack(): |
| 271 |
self.webview.goBack() |
| 272 |
elif self.pywebview_window.events.closing.set(): |
| 273 |
pass |
| 274 |
elif self.pywebview_window.confirm_close: |
| 275 |
self._quit_confirmation() |
| 276 |
else: |
| 277 |
app.pause() |
| 278 |
self.pywebview_window.events.closed.set() |
| 279 |
return True |
| 280 |
|
| 281 |
def get_size(self): |
| 282 |
lock = Semaphore(0) |
| 283 |
size = None, None |
| 284 |
|
| 285 |
@run_on_ui_thread |
| 286 |
def _get_size(): |
| 287 |
nonlocal size |
| 288 |
size = self.webview.getWidth(), self.webview.getHeight() |
| 289 |
lock.release() |
| 290 |
|
| 291 |
_get_size() |
| 292 |
lock.acquire() |
| 293 |
|
| 294 |
return size |
| 295 |
|
| 296 |
def get_url(self): |
| 297 |
lock = Semaphore(0) |
| 298 |
url = None |
| 299 |
|
| 300 |
@run_on_ui_thread |
| 301 |
def _get_url(): |
| 302 |
nonlocal url |
| 303 |
url = self.webview.getUrl() |
| 304 |
lock.release() |
| 305 |
|
| 306 |
_get_url() |
| 307 |
lock.acquire() |
| 308 |
|
| 309 |
return url |
| 310 |
|
| 311 |
@run_on_ui_thread |
| 312 |
def load_url(self, url): |
| 313 |
self.webview.loadUrl(url) |
| 314 |
|
| 315 |
@run_on_ui_thread |
| 316 |
def load_data_with_base_url(self, base_uri, html_content): |
| 317 |
self.webview.loadDataWithBaseURL(base_uri, html_content, 'text/html', 'UTF-8', None) |
| 318 |
|
| 319 |
|
| 320 |
class AndroidApp(App): |
| 321 |
def __init__(self, window): |
| 322 |
self.window = window |
| 323 |
self.first_show = True |
| 324 |
super().__init__() |
| 325 |
|
| 326 |
self.register_event_type('on_create') |
| 327 |
self.register_event_type('on_destroy') |
| 328 |
self.register_event_type('on_pause') |
| 329 |
self.register_event_type('on_resume') |
| 330 |
self.register_event_type('on_start') |
| 331 |
self.register_event_type('on_stop') |
| 332 |
|
| 333 |
def build_view(self): |
| 334 |
self.view = BrowserView(self.window) |
| 335 |
return self.view |
| 336 |
|
| 337 |
def on_pause(self, _): |
| 338 |
self.view.webview.pauseTimers() |
| 339 |
self.view.webview.onPause() |
| 340 |
|
| 341 |
logger.debug('pausing initiated') |
| 342 |
|
| 343 |
def on_resume(self, _): |
| 344 |
self.view.webview.onResume() |
| 345 |
self.view.webview.resumeTimers() |
| 346 |
|
| 347 |
def on_create(self, activity, saved_instance_state): |
| 348 |
"""Event handler for the `on_create` event which is fired after |
| 349 |
initialization (after build() has been called) but before the |
| 350 |
application has started running. |
| 351 |
""" |
| 352 |
|
| 353 |
def on_destroy(self, _): |
| 354 |
self.view.dismiss() |
| 355 |
|
| 356 |
def on_start(self, activity): |
| 357 |
"""Event handler for the `on_start` event which is fired when the |
| 358 |
application is becoming visible to the user. |
| 359 |
""" |
| 360 |
|
| 361 |
def on_stop(self, activity): |
| 362 |
"""Event handler for the `on_stop` event which is fired when the |
| 363 |
application is no longer visible to the user. |
| 364 |
""" |
| 365 |
|
| 366 |
|
| 367 |
def create_file_dialog(*_): |
| 368 |
logger.warning('Creating file dialogs is not supported on Android') |
| 369 |
|
| 370 |
|
| 371 |
def create_window(window): |
| 372 |
global app |
| 373 |
|
| 374 |
if app: |
| 375 |
logger.error('Multiple windows are not supported on Android') |
| 376 |
return |
| 377 |
|
| 378 |
app = AndroidApp(window) |
| 379 |
app.run() |
| 380 |
|
| 381 |
|
| 382 |
def setup_app(): |
| 383 |
pass |
| 384 |
|
| 385 |
|
| 386 |
def load_url(url, _): |
| 387 |
app.view._cookies = [] |
| 388 |
app.view.load_url(url) |
| 389 |
|
| 390 |
|
| 391 |
def load_html(html_content, base_uri, _): |
| 392 |
app.view._cookies = [] |
| 393 |
app.view.load_data_with_base_url(base_uri, html_content) |
| 394 |
|
| 395 |
|
| 396 |
def evaluate_js(js_code, _, parse_json=True): |
| 397 |
def callback(result): |
| 398 |
nonlocal js_result, value_callback |
| 399 |
try: |
| 400 |
# The result is double-encoded in Android, once by the WebView and once pywebview's stringify |
| 401 |
js_result = json.loads(result) if result else result |
| 402 |
js_result = json.loads(js_result) if parse_json and js_result else js_result |
| 403 |
except Exception as e: |
| 404 |
logger.exception(f'Error parsing result: {js_result}. Type: {type(js_result)}\n{e}') |
| 405 |
finally: |
| 406 |
value_callback = None |
| 407 |
lock.release() |
| 408 |
|
| 409 |
@run_on_ui_thread |
| 410 |
def _evaluate_js(): |
| 411 |
nonlocal value_callback |
| 412 |
try: |
| 413 |
value_callback = ValueCallback(callback) |
| 414 |
app.view.webview.evaluateJavascript(js_code, value_callback) |
| 415 |
except Exception as e: |
| 416 |
logger.error(f'Error evaluating JavaScript: {e}') |
| 417 |
# Ensure callback is cleared on error |
| 418 |
value_callback = None |
| 419 |
lock.release() |
| 420 |
|
| 421 |
lock = Semaphore(0) |
| 422 |
js_result = None |
| 423 |
value_callback = None |
| 424 |
|
| 425 |
_evaluate_js() |
| 426 |
lock.acquire() |
| 427 |
return js_result |
| 428 |
|
| 429 |
|
| 430 |
def clear_cookies(_): |
| 431 |
lock = Semaphore(0) |
| 432 |
|
| 433 |
@run_on_ui_thread |
| 434 |
def _clear_cookies(): |
| 435 |
cookie_manager = None |
| 436 |
try: |
| 437 |
# Get fresh CookieManager reference to avoid stale Java object references |
| 438 |
cookie_manager = CookieManager.getInstance() |
| 439 |
cookie_manager.removeAllCookies(None) |
| 440 |
except Exception as e: |
| 441 |
logger.error(f'Error clearing cookies: {e}') |
| 442 |
finally: |
| 443 |
# Clear the reference to help GC |
| 444 |
cookie_manager = None |
| 445 |
lock.release() |
| 446 |
|
| 447 |
app.view._cookies = [] |
| 448 |
_clear_cookies() |
| 449 |
lock.acquire() |
| 450 |
|
| 451 |
|
| 452 |
def get_cookies(_): |
| 453 |
cookies = app.view._cookies |
| 454 |
cookie_string = evaluate_js('document.cookie', None, False) |
| 455 |
|
| 456 |
try: |
| 457 |
current_url = app.view.get_url() |
| 458 |
|
| 459 |
# Parse URL once outside the loop to avoid repeated parsing |
| 460 |
parsed_url = urlparse(current_url) |
| 461 |
domain = parsed_url.netloc |
| 462 |
is_secure = current_url.startswith('https') |
| 463 |
|
| 464 |
# Parse the cookie string into individual cookies |
| 465 |
for cookie_pair in cookie_string.split(';'): |
| 466 |
cookie_pair = cookie_pair.strip() |
| 467 |
if '=' in cookie_pair: |
| 468 |
name, value = cookie_pair.split('=', 1) |
| 469 |
name = name.strip() |
| 470 |
|
| 471 |
existing_cookie = next((c for c in cookies if name in c), None) |
| 472 |
|
| 473 |
if existing_cookie and existing_cookie[name].value == value.strip(): |
| 474 |
# If the cookie already exists, skip it |
| 475 |
continue |
| 476 |
|
| 477 |
cookie_dict = { |
| 478 |
'name': name, |
| 479 |
'expires': None, # Android does not provide expiration in getCookie |
| 480 |
'value': value.strip(), |
| 481 |
'domain': domain, |
| 482 |
'path': '/', |
| 483 |
'secure': is_secure, |
| 484 |
'httponly': False, |
| 485 |
} |
| 486 |
|
| 487 |
cookies.append(create_cookie(cookie_dict)) |
| 488 |
except Exception as e: |
| 489 |
logger.exception(f'Error getting cookies: {e}') |
| 490 |
|
| 491 |
return cookies |
| 492 |
|
| 493 |
|
| 494 |
def get_current_url(_): |
| 495 |
lock = Semaphore(0) |
| 496 |
url = None |
| 497 |
|
| 498 |
@run_on_ui_thread |
| 499 |
def _get_current_url(): |
| 500 |
nonlocal url |
| 501 |
try: |
| 502 |
url = app.view.get_url() |
| 503 |
except Exception as e: |
| 504 |
logger.error(f'Error getting current URL: {e}') |
| 505 |
finally: |
| 506 |
lock.release() |
| 507 |
|
| 508 |
_get_current_url() |
| 509 |
lock.acquire() |
| 510 |
return url |
| 511 |
|
| 512 |
|
| 513 |
def get_screens(): |
| 514 |
logger.warning('Screen information is not supported on Android') |
| 515 |
return [] |
| 516 |
|
| 517 |
|
| 518 |
def get_size(_): |
| 519 |
return app.view.get_size() |
| 520 |
|
| 521 |
|
| 522 |
def get_position(_): |
| 523 |
return (0, 0) |
| 524 |
|
| 525 |
|
| 526 |
def show(_): |
| 527 |
logger.warning('Showing window is not supported on Android') |
| 528 |
|
| 529 |
|
| 530 |
def hide(_): |
| 531 |
app.pause() |
| 532 |
|
| 533 |
|
| 534 |
def minimize(_): |
| 535 |
app.pause() |
| 536 |
|
| 537 |
|
| 538 |
def move(_): |
| 539 |
logger.warning('Moving window is not supported on Android') |
| 540 |
|
| 541 |
|
| 542 |
def restore(_): |
| 543 |
logger.warning('Restoring window is not supported on Android') |
| 544 |
|
| 545 |
|
| 546 |
def resize(width, height, _, fix_point): |
| 547 |
logger.warning('Resizing window is not supported on Android') |
| 548 |
|
| 549 |
|
| 550 |
def destroy_window(): |
| 551 |
app.stop() |
| 552 |
|
| 553 |
|
| 554 |
def set_title(title, _): |
| 555 |
logger.warning('Changing app title is not supported on Android') |
| 556 |
|
| 557 |
|
| 558 |
def set_on_top(_, on_top): |
| 559 |
logger.warning('Always on top mode is not supported on Android') |
| 560 |
|
| 561 |
|
| 562 |
@run_on_ui_thread |
| 563 |
def toggle_fullscreen(_): |
| 564 |
is_fullscreen = app.view.is_fullscreen |
| 565 |
|
| 566 |
try: |
| 567 |
if not is_fullscreen: |
| 568 |
option = ( |
| 569 |
View.SYSTEM_UI_FLAG_FULLSCREEN |
| 570 |
| View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
| 571 |
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
| 572 |
| View.SYSTEM_UI_FLAG_LAYOUT_STABLE |
| 573 |
| View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
| 574 |
| View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
| 575 |
) |
| 576 |
app.view.webview.setSystemUiVisibility(option) |
| 577 |
app.view.is_fullscreen = True |
| 578 |
else: |
| 579 |
option = View.SYSTEM_UI_FLAG_VISIBLE |
| 580 |
app.view.webview.setSystemUiVisibility(option) |
| 581 |
app.view.is_fullscreen = False |
| 582 |
except Exception as e: |
| 583 |
logger.error(f'Error toggling fullscreen: {e}') |
| 584 |
|
| 585 |
|
| 586 |
def add_tls_cert(certfile): |
| 587 |
pass |