Trying to minimize events latency between windows

[pvpswaghd]

Hey! I am working on communicating between two windows using events. My frontend is built by NextJS with TypeScript. For the main window, it will create a secondary window through an argument (processed by Rust backend), meanwhile parsing in some extra arguments to the secondary window.

For the main window, I tried to establish a handshake. Note that this is a function to handle the creation of the window:

const handleAction = async (
        command: string,
        args: string[],
        fullInput: string
    ) => {
        const windowCreatedPromise = new Promise<boolean>(async (resolve) => {
            const unlisten = await listen<string>("window_created", (event) => {
                console.log("Window created", event.payload);
                resolve(true);
                unlisten();
            });
        });
        invoke("create_window", { name: command });
        // This promise will be fulfilled by the Rust backend if the window exist, and fulfilled by the creation of the window if the window is just being created
        await windowCreatedPromise;
        const waitToSend = new Promise((resolve) => setTimeout(resolve, 500));
        await waitToSend;
        await emitTo("im", "targetfield", {
            args: args[0],
            command: command,
        });
        console.log(
            "Window creation completed, proceeding with additional actions"
        );
    };

For the secondary window, I have the following:

useEffect(() => {
        if (!isWebSocketReady) return;

        const setupTauriListener = async () => {
            try {
                // Fulfilling the promise in the main window
                await emitTo("main", "window_created", "from im");
                const unlisten = await listen<any>("targetfield", (event) => {
                    console.log("Received event", event.payload);
                });
                unlistenRef.current = unlisten;
                console.log("Tauri listener setup complete");
            } catch (error) {
                console.error("Tauri listener setup failed:", error);
            }
        };

        setupTauriListener();

        return () => {
            if (unlistenRef.current) {
                unlistenRef.current();
            }
        };
    }, [isWebSocketReady, chatData, loadChatMessages]);

This works only if I set a Promise on a 0.5s delay, so that it can be retrieved by the backend. Originally, I thought the establishment of a Websocket connection hinders the delay, but apparently it isn't. I tried to put the listener at the very end of initialization, to try to make sure that the listener establishs after the render has finished. However, after some testing, this 0.5s delay is still needed to load the message.

Is it normal to have such a huge latency between multi-window communication in Tauri? If not, is there any suggestions on how to optimize it? I don't want this to always wait for 0.5 seconds to be able to retrieve the request.

[FabianLars]

500ms sounds a bit much but maybe it's a debug build thing. couldn't you just swap the await listen("targetfield") and await emitTo("main", "window_created") lines? listen should return once it's registered so you shouldn't need a manual (potentially inaccurate) timeout.