Feature: Implement Callback Functions for JavaScript Evaluation Result

[Toromyx]

Problem
I use Tauri to open windows of external sites as well as the "main" application window of local HTML/JS/CSS. I still want to interact with the DOM of those external sites and know the result of that interaction. This doesn't have to be done via JavaScript.

Solution
All three webview APIs on the main operating systems support some kind of callback when executing JavaScript. For each os I added a link to the documentation and the place in the code where that callback possibility is just ignored.
Is there a (security) reason this functionality is not provided?

Linux

• https://webkitgtk.org/reference/webkit2gtk/stable/WebKitWebView.html#webkit-web-view-run-javascript
• https://github.com/tauri-apps/wry/blob/next/src/webview/webkitgtk/mod.rs#L304

Windows

• https://docs.microsoft.com/en-us/microsoft-edge/webview2/reference/win32/icorewebview2?view=webview2-1.0.1072.54#executescript
• https://github.com/tauri-apps/wry/blob/next/src/webview/webview2/mod.rs#L561
• https://github.com/tauri-apps/wry/blob/next/src/webview/webview2/mod.rs#L550

Apple

• https://developer.apple.com/documentation/webkit/wkwebview/1415017-evaluatejavascript
• https://github.com/tauri-apps/wry/blob/next/src/webview/wkwebview/mod.rs#L414

Alternatives
An alternative I considered was to build a JavaScript wrapper which sends the result of the evaluated JavaScript over RPC. But this would be a security problem because now external sites have access to RPC.

Would you assign yourself to implement this feature?
I'm only just starting with Rust and would assign myself to do a proof of concept for WebView2 under Windows. I currently don't have the capability to develop under Linux and never will have the capability to develop under Apple.

[wusyong]

I think this one is just because of history reason. When webview repo provide the API, it just want one that can run js script.
We do can support this but it won't be a trivial task IMHO. It's better wait for v1 launch and see what feature requests are wanted by most.

[Toromyx]

I hacked together something which "works on my machine" (meaning Windows):

• next...Toromyx:eval-callback
• tauri-apps/tauri@next...Toromyx:eval-callback

I'm open for feedback, but I also understand if you say that now is not the right time to implement this feature.

[yyon]

Hello,
I happened to implement this on all 3 OS's (using Tauri's with_webview function). If you ever happen to want to implement this feature, feel free to use this code as a reference.

let webview_result = browser_window.with_webview(|webview| {
    #[cfg(target_os = "linux")]
    {
        use webkit2gtk::traits::WebViewExt;
        use gio;
        let cancellable: Option<&gio::Cancellable> = None;
        webview.inner().run_javascript("JSON.stringify(\"Hello, world!\");", cancellable, |result| {
            if result.is_err() {
                println!("Error evaluating javascript");
                return;
            }

            let javascript_result = result.unwrap();

            let value_opt = javascript_result.js_value();

            if value_opt.is_none() {
                println!("Javascript returned nothing");
                return;
            }

            let value_val = value_opt.unwrap();

            let value_str = value_val.to_string();

            do_callback(value_str);
        });
    }

    #[cfg(windows)]
    unsafe {
        use webview2_com::{Microsoft::Web::WebView2::Win32::*, *};
        use windows::{
            core::{PCWSTR, PWSTR},
        };
        use std::os::windows::ffi::OsStrExt;

        let core_result = webview.controller().CoreWebView2();

        if core_result.is_err() {
            println!("Error getting core webview");
            return;
        }

        let core = core_result.unwrap();

        fn encode_wide(string: impl AsRef<std::ffi::OsStr>) -> Vec<u16> {
            string.as_ref().encode_wide().chain(std::iter::once(0)).collect()
        }

        let _res = core.ExecuteScript(
            PCWSTR::from_raw(encode_wide("JSON.stringify(\"Hello, world!\");".to_string()).as_ptr()),
            &ExecuteScriptCompletedHandler::create(Box::new(|result, result_object_as_json: std::string::String| {
                // note: result_object_as_json is wrapped in JSON twice, as opposed to other OS's, because for some reason it can only return strings
                // so you should probably parse JSON here
                do_callback(result_object_as_json);
                Ok(())
            }))
        );
    }

    #[cfg(target_os = "macos")]
    unsafe {
        use objc;
        use objc::sel;
        use objc::sel_impl;
        use cocoa::base::id;
        const UTF8_ENCODING: usize = 4;
        struct NSString(id);
        impl NSString {
            fn new(s: &str) -> Self {
                NSString(unsafe {
                let ns_string: id = objc::msg_send![objc::class!(NSString), alloc];
                let ns_string: id = objc::msg_send![ns_string,
                                        initWithBytes:s.as_ptr()
                                        length:s.len()
                                        encoding:UTF8_ENCODING];
        
                let _: () = objc::msg_send![ns_string, autorelease];
        
                ns_string
                })
            }
        
            fn to_str(&self) -> &str {
                unsafe {
                let bytes: *const std::ffi::c_char = objc::msg_send![self.0, UTF8String];
                let len = objc::msg_send![self.0, lengthOfBytesUsingEncoding: UTF8_ENCODING];
                let bytes = std::slice::from_raw_parts(bytes as *const u8, len);
                std::str::from_utf8_unchecked(bytes)
                }
            }
        }
        struct NSError(id);
        use block2::{Block, ConcreteBlock};

        let controller = webview.inner();
        let javascript_string = NSString::new("JSON.stringify(\"Hello, world!\");");
        let handler = ConcreteBlock::new(|val: NSString, err| {
            do_callback(val.to_str().to_string());
        });
        let handler = handler.copy();
        let handler: &Block<(NSString, NSError), ()> = &handler;

        let _: id = objc::msg_send![controller, evaluateJavaScript:javascript_string completionHandler:handler];
    }
});