Global hotkeys

[kostya9]

Does Avalonia have global hotkey capability?

On Windows, technically, I could use RegisterHotKey to do that, but I'm not sure how to hook into the Avalonia WinProc procedure handling in order to get the WM_HOTKEY message.

[jp2masa]

I'm not sure how to hook into the Avalonia WinProc procedure handling in order to get the WM_HOTKEY message.

This should work: #8650 (comment)

[kostya9]

Thanks for the pointer! Unfortunately didn't find a way how to get a window handle w/o a main window (e.g. a Tray app), but luckily I can get one by hacking into Win32Platform via reflection.

My sample code for anyone wanting to solve the same problem (used TerraFX.Interop.Windows for windows interop bindings):

using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using Avalonia;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Markup.Xaml;
using Avalonia.Platform;
using Avalonia.Win32;
using TerraFX.Interop.Windows;

public partial class App : Application
{
    public override void Initialize()
    {
        AvaloniaXamlLoader.Load(this);

        AvaloniaWinProcHelper.Init();

        Windows.RegisterHotKey(AvaloniaWinProcHelper.WindowHandle, 1, MOD.MOD_ALT, VK.VK_F1);
    }

    public override unsafe void OnFrameworkInitializationCompleted()
    {
        base.OnFrameworkInitializationCompleted();
    }
}

public static unsafe class AvaloniaWinProcHelper
{
    private static delegate* unmanaged<HWND, uint, WPARAM, LPARAM, LRESULT> _wrappedAvaloniaWinProc;

    public static HWND WindowHandle { get; private set; }

    public static void Init()
    {
        var win32Platform = (Win32Platform)AvaloniaLocator.Current.GetService<IWindowingPlatform>();

        WindowHandle = (HWND)(nint)(w.GetType().GetProperty("Handle", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(win32Platform));

        _wrappedAvaloniaWinProc = (delegate* unmanaged<HWND, uint, WPARAM, LPARAM, LRESULT>)Windows.GetWindowLongPtr(WindowHandle, GWLP.GWLP_WNDPROC);
        delegate* unmanaged<HWND, uint, WPARAM, LPARAM, LRESULT> wrapperWinProc = &WndProcHook;
        Windows.SetWindowLongPtr(WindowHandle, GWLP.GWLP_WNDPROC, (nint)wrapperWinProc);
    }

    [UnmanagedCallersOnly]
    public static LRESULT WndProcHook(HWND hwnd, uint code, WPARAM wParam, LPARAM lParam)
    {
        Debug.WriteLine($"msg - {code}");

        if (code == WM.WM_HOTKEY)
        {
            Debug.WriteLine("!!hotkey clicked!!");
        }

        return _wrappedAvaloniaWinProc(hwnd, code, wParam, lParam);
    }

[caesay]

For anyone finding this in the future, if you don't want to hack into Avalonia with reflection or use unsafe code, you can do this by just opening your own window with CreateWindowEx. For example:

public static class User32Hotkey
{
    static WindowProc _wndProcDelegate;
    static HWND _hwnd;
    static Dictionary<int, Action> _registeredKeys = new();

    static User32Hotkey()
    {
        CreateMessageWindow();
    }

    public static IDisposable Create(Key key, ModifierKeys modifiers, Action execute)
    {
        int virtualKeyCode = KeyInterop.VirtualKeyFromKey(key);
        var id = virtualKeyCode + ((int)modifiers * 0x10000);
        if (_registeredKeys.ContainsKey(id))
            throw new InvalidOperationException("Hot key with this key combination is already registered by this application.");

        if (!RegisterHotKey(_hwnd, id, (HotKeyModifiers)modifiers, (uint)virtualKeyCode))
            throw new Win32Exception();

        _registeredKeys.Add(id, execute);

        return Disposable.Create(() =>
        {
            UnregisterHotKey(_hwnd, id);
            _registeredKeys.Remove(id);
        });
    }

    private static void CreateMessageWindow()
    {
        // Ensure that the delegate doesn't get garbage collected by storing it as a field.
        _wndProcDelegate = new WindowProc(WndProc);

        WNDCLASSEX wndClassEx = new WNDCLASSEX
        {
            cbSize = (uint)Marshal.SizeOf<WNDCLASSEX>(),
            lpfnWndProc = _wndProcDelegate,
            hInstance = GetModuleHandle(null),
            lpszClassName = "YourAppNameOrSomething" + Guid.NewGuid(),
        };

        ushort atom = RegisterClassEx(wndClassEx);

        if (atom == 0)
            throw new Win32Exception();

        _hwnd = CreateWindowEx(0, (IntPtr)atom, null, 0, 0, 0, 0, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
        if (_hwnd.IsNull)
            throw new Win32Exception();
    }

    private static IntPtr WndProc(HWND hwnd, uint uMsg, IntPtr wParam, IntPtr lParam)
    {
        if (uMsg == (uint)WindowMessage.WM_HOTKEY && _registeredKeys.TryGetValue((int)wParam, out var action))
        {
            action();
        }

        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
}

[MrDoe]

Does anyone have a solution for Linux/X11 for implementing global hotkeys?

[thevortexcloud]

Depends on your environment. If you are using X11 then you can use https://github.com/TolikPylypchuk/SharpHook

From memory Wayland does have (or will have?) some protocols for single key global shotcuts for things like push to talk. But I don't know of any C# library that currently supports it.

Otherwise you can technically read raw keyboard data from the keyboard device under /dev/input. It's just in a binary format so you do need to decode it. But by default you need root to be able to read it.