Erfassen von Tastenanschlägen ohne Fokus

Question

z. Mit Winamp (zumindest unter Windows) können Sie ein Spiel im Vollbildmodus mit Winamp im Hintergrund spielen und mit den Media-Tasten * den Sound steuern. Winamp muss nicht fokussiert werden, damit das Spiel im Vollbildmodus fortgesetzt werden kann.

Ich würde es vorziehen, dies in Java zu schreiben, aber das ist wahrscheinlich zur Arbeit geht nicht (Tastatureingaben, ohne den Fokus Fang schon schwierig in Java afaik), so dass jede C# Lösung ist auch in Ordnung.

Die grundlegende Frage ist also: wie Tastenanschläge ohne Fokus zu erfassen?

*) Ich glaube, dass die 'zurück/vorwärts/stop/mail/suche/favoriten/web/home' buttons media buttons heißen, aber ein besserer name wäre willkommen :).

Answer 1

Low-Level-Windows-Hooks ist eine Möglichkeit, dies zu tun. Hier ist eine article und hier ist ein wenig mehr Infos von MSDN.

Dies ist eine Teilansicht von dem, was dieser Code aussehen kann:

private IntPtr LowLevelKeyboardHook(int nCode, WindowsMessages wParam, [In] KBDLLHOOKSTRUCT lParam) 
    { 
     bool callNext = true; 

     bool isKeyDown = (wParam == WindowsMessages.KEYDOWN || wParam == WindowsMessages.SYSKEYDOWN); 
     bool isKeyUp = (wParam == WindowsMessages.KEYUP || wParam == WindowsMessages.SYSKEYUP); 

     if ((nCode >= 0) && (isKeyDown || isKeyUp)) 
     { 
      // the virtual key codes and the winforms Keys have the same enumeration 
      // so we can freely cast back and forth between them 
      Keys key = (Keys)lParam.vkCode; 

      // Do your other processing here... 
     } 

     // if any handler returned false, trap the message 
     return (callNext) ? User32.CallNextHookEx(_mainHook, nCode, wParam, lParam) : _nullNext; 
    } 


    /// <summary> 
    /// Registers the user's LowLevelKeyboardProc with the system in order to 
    /// intercept any keyboard events before processed in the regular fashion. 
    /// This can be used to log all keyboard events or ignore them. 
    /// </summary> 
    /// <param name="hook">Callback function to call whenever a keyboard event occurs.</param> 
    /// <returns>The IntPtr assigned by the Windows's sytem that defines the callback.</returns> 
    private IntPtr RegisterLowLevelHook(LowLevelKeyboardProc hook) 
    { 
     IntPtr handle = IntPtr.Zero; 

     using (Process currentProcess = Process.GetCurrentProcess()) 
     using (ProcessModule currentModule = currentProcess.MainModule) 
     { 
      IntPtr module = Kernel32.GetModuleHandle(currentModule.ModuleName); 
      handle = User32.SetWindowsHookEx(HookType.KEYBOARD_LL, hook, module, 0); 
     } 

     return handle; 
    } 

    /// <summary> 
    /// Unregisters a previously registered callback from the low-level chain. 
    /// </summary> 
    /// <param name="hook">IntPtr previously assigned to the low-level chain. 
    /// Users should have stored the value given by 
    /// <see cref="Drs.Interop.Win32.LowLevelKeyboard.RegisterLowLevelHook"/>, 
    /// and use that value as the parameter into this function.</param> 
    /// <returns>True if the hook was removed, false otherwise.</returns> 
    private bool UnregisterLowLevelHook(IntPtr hook) 
    { 
     return User32.UnhookWindowsHookEx(hook); 
    } 

Gerade implementieren alle P/Invoke Erklärungen benötigt werden, und es sollte funktionieren. Ich verwende diesen Ansatz in meiner Anwendung und es funktioniert gut.

Answer 2

In Java gibt es zwei Bibliotheken, die dies tun können:

• JIntellitype (Windows)
• JXGrabKey (X11)