feat: expand permission handling API and add Android support

Signed-off-by: F0RLE <lrshka.klim7766@gmail.com>

Author: F0RLE

.changes/permission-handler.md

@@ -2,4 +2,9 @@
 "wry": minor
 ---
 
-feat: add permission handler API for WebView2
+Add an expanded permission handling API for WebView2, WKWebView, and WebKitGTK.
+This includes:
+- `PermissionKind` expansion (Midi, Nfc, Bluetooth, Sensors, MediaKeySystemAccess, LocalFonts, WindowManagement).
+- Support for `PermissionResponse::Prompt`.
+- Android support (experimental) via JNI.
+- Improved macOS permission splitting for camera and microphone.

src/android/binding.rs

@@ -16,11 +16,11 @@ pub use jni::{
 pub use ndk;
 
 use super::{
-  ASSET_LOADER_DOMAIN, EVAL_CALLBACKS, IPC, ON_LOAD_HANDLER, REQUEST_HANDLER, TITLE_CHANGE_HANDLER,
-  URL_LOADING_OVERRIDE, WITH_ASSET_LOADER,
+  ASSET_LOADER_DOMAIN, EVAL_CALLBACKS, IPC, ON_LOAD_HANDLER, PERMISSION_HANDLER, REQUEST_HANDLER,
+  TITLE_CHANGE_HANDLER, URL_LOADING_OVERRIDE, WITH_ASSET_LOADER,
 };
 
-use crate::PageLoadEvent;
+use crate::{PageLoadEvent, PermissionKind, PermissionResponse};
 
 #[macro_export]
 macro_rules! android_binding {
@@ -97,6 +97,14 @@ macro_rules! android_binding {
       handleReceivedTitle,
       [JObject, JString],
     );
+    android_fn!(
+      $domain,
+      $package,
+      RustWebChromeClient,
+      onPermissionRequestNative,
+      [jni::objects::JObjectArray],
+      jint
+    );
   }};
 }
 
@@ -413,3 +421,53 @@ pub unsafe fn onPageLoaded(mut env: JNIEnv, _: JClass, url: JString) {
     }
   }
 }
+
+pub unsafe fn onPermissionRequestNative(
+  mut env: JNIEnv,
+  _: JClass,
+  resources: jni::objects::JObjectArray,
+) -> jint {
+  let mut kind = PermissionKind::Other;
+
+  if let Ok(size) = env.get_array_length(&resources) {
+    for i in 0..size {
+      if let Ok(resource) = env.get_object_array_element(&resources, i) {
+        if let Ok(resource_str) = env.get_string(&resource.into()) {
+          let resource_str = resource_str.to_string_lossy();
+
+          match resource_str.as_ref() {
+            "android.webkit.resource.AUDIO_CAPTURE" => {
+              kind = PermissionKind::Microphone;
+              break;
+            }
+            "android.webkit.resource.VIDEO_CAPTURE" => {
+              kind = PermissionKind::Camera;
+              break;
+            }
+            "android.webkit.resource.PROTECTED_MEDIA_ID" => {
+              kind = PermissionKind::MediaKeySystemAccess;
+              break;
+            }
+            "android.webkit.resource.MIDI_SYSEX" => {
+              kind = PermissionKind::Midi;
+              break;
+            }
+            _ => {}
+          }
+        }
+      }
+    }
+  }
+
+  if let Some(handler) = &*PERMISSION_HANDLER.lock().unwrap() {
+    let response = (handler.handler)(kind);
+    match response {
+      PermissionResponse::Allow => 0,
+      PermissionResponse::Deny => 1,
+      PermissionResponse::Default => 2,
+      PermissionResponse::Prompt => 3,
+    }
+  } else {
+    2 // Default
+  }
+}

src/android/kotlin/RustWebChromeClient.kt

@@ -92,6 +92,24 @@ class RustWebChromeClient(appActivity: WryActivity) : WebChromeClient() {
   }
 
   override fun onPermissionRequest(request: PermissionRequest) {
+    val response = onPermissionRequestNative(request.resources)
+    when (response) {
+      0 -> { // Allow
+        request.grant(request.resources)
+        return
+      }
+      1 -> { // Deny
+        request.deny()
+        return
+      }
+      2 -> { // Default
+        // Continue with default logic
+      }
+      3 -> { // Prompt
+        // Continue with default logic (which prompts)
+      }
+    }
+
     val isRequestPermissionRequired = Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
     val permissionList: MutableList<String> = ArrayList()
     if (listOf(*request.resources).contains("android.webkit.resource.VIDEO_CAPTURE")) {
@@ -118,6 +136,8 @@ class RustWebChromeClient(appActivity: WryActivity) : WebChromeClient() {
     }
   }
 
+  private external fun onPermissionRequestNative(resources: Array<String>): Int
+
   /**
    * Show the browser alert modal
    * @param view
@@ -482,12 +502,15 @@ class RustWebChromeClient(appActivity: WryActivity) : WebChromeClient() {
     return File.createTempFile(imageFileName, ".jpg", storageDir)
   }
 
-  override fun onReceivedTitle(
-      view: WebView,
-      title: String
-  ) {
-    handleReceivedTitle(view, title)
+  override fun onPermissionRequest(request: PermissionRequest) {
+    val result = onPermissionRequestNative(request.resources)
+    when (result) {
+      0 -> request.grant(request.resources)
+      1 -> request.deny()
+      else -> super.onPermissionRequest(request)
+    }
   }
 
+  private external fun onPermissionRequestNative(resources: Array<String>): Int
   private external fun handleReceivedTitle(webview: WebView, title: String)
 }

src/android/mod.rs

@@ -81,6 +81,7 @@ define_static_handlers! {
   TITLE_CHANGE_HANDLER = UnsafeTitleHandler { handler: Box<dyn Fn(String)> };
   URL_LOADING_OVERRIDE = UnsafeUrlLoadingOverride { handler: Box<dyn Fn(String) -> bool> };
   ON_LOAD_HANDLER = UnsafeOnPageLoadHandler { handler: Box<dyn Fn(PageLoadEvent, String)> };
+  PERMISSION_HANDLER = UnsafePermissionHandler { handler: Box<dyn Fn(PermissionKind) -> PermissionResponse> };
 }
 
 pub static WITH_ASSET_LOADER: StaticValue<Option<bool>> = StaticValue(Mutex::new(None));

src/lib.rs

@@ -553,6 +553,20 @@ pub enum PermissionKind {
   ClipboardRead,
   /// Display capture permission (for getDisplayMedia).
   DisplayCapture,
+  /// Midi access permission.
+  Midi,
+  /// Nfc access permission.
+  Nfc,
+  /// Bluetooth access permission.
+  Bluetooth,
+  /// Sensors (accelerometer, gyroscope, etc.) access permission.
+  Sensors,
+  /// Media key system access permission.
+  MediaKeySystemAccess,
+  /// Local fonts access permission.
+  LocalFonts,
+  /// Window management permission.
+  WindowManagement,
   /// Other unrecognized permission type.
   Other,
 }
@@ -839,12 +853,17 @@ pub struct WebViewAttributes<'a> {
   /// The handler receives the [`PermissionKind`] and should return
   /// the desired [`PermissionResponse`].
   ///
+  /// > [!NOTE]
+  /// > This handler only triggers for new permission requests. If the user has already
+  /// > allowed or denied a permission persistently within the webview, the browser
+  /// > will use the saved preference instead of calling this handler.
+  ///
   /// ## Platform-specific:
   ///
   /// - **Windows**: Fully supported via WebView2's PermissionRequested event.
   /// - **macOS / iOS**: Fully supported via WKUIDelegate's requestMediaCapturePermission.
   /// - **Linux**: Fully supported via WebKitGTK's permission-request signal.
-  /// - **Android**: Not yet implemented, handler is ignored.
+  /// - **Android**: Experimental support implemented via JNI.
   ///
   /// ## Example
   ///

src/webkitgtk/mod.rs

@@ -578,28 +578,27 @@ impl InnerWebView {
 
     // Permission handler
     if let Some(permission_handler) = attributes.permission_handler.take() {
-      let permission_handler = Rc::new(permission_handler);
       webview.connect_permission_request(move |_webview, request| {
         // Determine permission kind
-        let permission_kind = if request
-          .downcast_ref::<UserMediaPermissionRequest>()
-          .is_some()
-        {
-          let media_request = request
-            .downcast_ref::<UserMediaPermissionRequest>()
-            .unwrap();
-          if media_request.is_for_audio_device() {
-            PermissionKind::Microphone
-          } else if media_request.is_for_video_device() {
-            PermissionKind::Camera
+        let permission_kind =
+          if let Some(media_request) = request.downcast_ref::<UserMediaPermissionRequest>() {
+            if media_request.is_for_audio_device() {
+              PermissionKind::Microphone
+            } else if media_request.is_for_video_device() {
+              PermissionKind::Camera
+            } else {
+              // TODO: Use is_for_display_device() when we bump to WebKitGTK 2.42
+              PermissionKind::DisplayCapture
+            }
+          } else if request.type_().name() == "WebKitGeolocationPermissionRequest" {
+            PermissionKind::Geolocation
+          } else if request.type_().name() == "WebKitNotificationPermissionRequest" {
+            PermissionKind::Notifications
+          } else if request.type_().name() == "WebKitPointerLockPermissionRequest" {
+            PermissionKind::Other // Pointer lock not yet in PermissionKind
           } else {
-            // TODO: Use is_for_display_device() when we bump to WebKitGTK 2.42
-            PermissionKind::DisplayCapture
-          }
-        } else {
-          // Could be GeolocationPermissionRequest, NotificationPermissionRequest, etc.
-          PermissionKind::Other
-        };
+            PermissionKind::Other
+          };
 
         // Call user's permission handler
         let response = permission_handler(permission_kind);
@@ -614,10 +613,7 @@ impl InnerWebView {
             request.deny();
             true // handled
           }
-          PermissionResponse::Default => {
-            false // not handled, let WebKitGTK show default prompt
-          }
-          PermissionResponse::Prompt => {
+          PermissionResponse::Default | PermissionResponse::Prompt => {
             false // not handled, let WebKitGTK show default prompt
           }
         }

src/webview2/mod.rs

@@ -511,7 +511,6 @@ impl InnerWebView {
 
     // Permission handler
     if let Some(permission_handler) = attributes.permission_handler.take() {
-      let permission_handler = Rc::new(permission_handler);
       unsafe {
         webview.add_PermissionRequested(
           &PermissionRequestedEventHandler::create(Box::new(move |_, args| {
@@ -527,6 +526,7 @@ impl InnerWebView {
               COREWEBVIEW2_PERMISSION_KIND_GEOLOCATION => PermissionKind::Geolocation,
               COREWEBVIEW2_PERMISSION_KIND_NOTIFICATIONS => PermissionKind::Notifications,
               COREWEBVIEW2_PERMISSION_KIND_CLIPBOARD_READ => PermissionKind::ClipboardRead,
+              COREWEBVIEW2_PERMISSION_KIND_LOCAL_FONTS => PermissionKind::LocalFonts,
               _ => PermissionKind::Other,
             };
 
@@ -541,10 +541,7 @@ impl InnerWebView {
               PermissionResponse::Deny => {
                 args.SetState(COREWEBVIEW2_PERMISSION_STATE_DENY)?;
               }
-              PermissionResponse::Default => {
-                // Do nothing, let WebView2 show default prompt
-              }
-              PermissionResponse::Prompt => {
+              PermissionResponse::Default | PermissionResponse::Prompt => {
                 // Do nothing, let WebView2 show default prompt
               }
             }

src/wkwebview/class/wry_web_view_ui_delegate.rs

@@ -136,24 +136,44 @@ define_class!(
       capture_type: WKMediaCaptureType,
       decision_handler: &Block<dyn Fn(WKPermissionDecision)>,
     ) {
-      // Determine permission kind based on capture type
-      let permission_kind = match capture_type {
-        WKMediaCaptureType::Camera => PermissionKind::Camera,
-        WKMediaCaptureType::Microphone => PermissionKind::Microphone,
-        WKMediaCaptureType::CameraAndMicrophone => PermissionKind::Microphone, // Treat as microphone for now
-        _ => PermissionKind::Other,
-      };
-
       // Call user's permission handler if set
       let decision = if let Some(handler) = &self.ivars().permission_handler {
-        match handler(permission_kind) {
-          PermissionResponse::Allow => WKPermissionDecision::Grant,
-          PermissionResponse::Deny => WKPermissionDecision::Deny,
-          PermissionResponse::Default => WKPermissionDecision::Grant, // Default to grant for backwards compatibility
-          PermissionResponse::Prompt => WKPermissionDecision::Prompt,
+        match capture_type {
+          WKMediaCaptureType::Camera => match handler(PermissionKind::Camera) {
+            PermissionResponse::Allow => WKPermissionDecision::Grant,
+            PermissionResponse::Deny => WKPermissionDecision::Deny,
+            PermissionResponse::Default => WKPermissionDecision::Grant,
+            PermissionResponse::Prompt => WKPermissionDecision::Prompt,
+          },
+          WKMediaCaptureType::Microphone => match handler(PermissionKind::Microphone) {
+            PermissionResponse::Allow => WKPermissionDecision::Grant,
+            PermissionResponse::Deny => WKPermissionDecision::Deny,
+            PermissionResponse::Default => WKPermissionDecision::Grant,
+            PermissionResponse::Prompt => WKPermissionDecision::Prompt,
+          },
+          WKMediaCaptureType::CameraAndMicrophone => {
+            let mic_res = handler(PermissionKind::Microphone);
+            let cam_res = handler(PermissionKind::Camera);
+
+            match (mic_res, cam_res) {
+              (PermissionResponse::Allow, PermissionResponse::Allow) => WKPermissionDecision::Grant,
+              (PermissionResponse::Deny, _) | (_, PermissionResponse::Deny) => {
+                WKPermissionDecision::Deny
+              }
+              (PermissionResponse::Prompt, _) | (_, PermissionResponse::Prompt) => {
+                WKPermissionDecision::Prompt
+              }
+              _ => WKPermissionDecision::Grant,
+            }
+          }
+          _ => match handler(PermissionKind::Other) {
+            PermissionResponse::Allow => WKPermissionDecision::Grant,
+            PermissionResponse::Deny => WKPermissionDecision::Deny,
+            PermissionResponse::Default => WKPermissionDecision::Grant,
+            PermissionResponse::Prompt => WKPermissionDecision::Prompt,
+          },
         }
       } else {
-        // No handler set, default to grant (backwards compatible behavior)
         WKPermissionDecision::Grant
       };