Debian Codegraph @

webview/platforms/android/__init__.py

raw
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