all: support keyup event (windows)

Updates #9
Fixes #10

Author: changkun

examples/minimum/main.go

@@ -5,20 +5,51 @@
 package main
 
 import (
+	"log"
+	"sync"
+
 	"golang.design/x/hotkey"
 	"golang.design/x/hotkey/mainthread"
 )
 
 func main() { mainthread.Init(fn) }
 func fn() {
-	hk := hotkey.New([]hotkey.Modifier{hotkey.ModCtrl}, hotkey.KeyS)
-	var err error
-	if mainthread.Call(func() { err = hk.Register() }); err != nil {
-		panic(err)
-	}
+	wg := sync.WaitGroup{}
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
 
-	for range hk.Keydown() {
-		println("hotkey ctrl+s is triggered, exit the application, good bye!")
-		hk.Unregister()
+		err := listenHotkey(hotkey.KeyS, hotkey.ModCtrl, hotkey.ModShift)
+		if err != nil {
+			log.Println(err)
+		}
+	}()
+	go func() {
+		defer wg.Done()
+
+		err := listenHotkey(hotkey.KeyA, hotkey.ModCtrl, hotkey.ModShift)
+		if err != nil {
+			log.Println(err)
+		}
+	}()
+	wg.Wait()
+}
+
+func listenHotkey(key hotkey.Key, mods ...hotkey.Modifier) (err error) {
+	ms := []hotkey.Modifier{}
+	ms = append(ms, mods...)
+	hk := hotkey.New(ms, key)
+
+	mainthread.Call(func() { err = hk.Register() })
+	if err != nil {
+		return
 	}
+
+	// Blocks until the hokey is triggered.
+	<-hk.Keydown()
+	log.Printf("hotkey: %v is down\n", hk)
+	<-hk.Keyup()
+	log.Printf("hotkey: %v is up\n", hk)
+	hk.Unregister()
+	return
 }

hotkey.go

@@ -20,6 +20,11 @@
 // folder for more examples.
 package hotkey
 
+import (
+	"fmt"
+	"runtime"
+)
+
 // Event represents a hotkey event
 type Event struct{}
 
@@ -30,13 +35,33 @@ type Hotkey struct {
 	mods []Modifier
 	key  Key
 
-	in  chan<- Event
-	out <-chan Event
+	keydownIn  chan<- Event
+	keydownOut <-chan Event
+	keyupIn    chan<- Event
+	keyupOut   <-chan Event
 }
 
 func New(mods []Modifier, key Key) *Hotkey {
-	in, out := newEventChan()
-	return &Hotkey{mods: mods, key: key, in: in, out: out}
+	keydownIn, keydownOut := newEventChan()
+	keyupIn, keyupOut := newEventChan()
+	hk := &Hotkey{
+		mods:       mods,
+		key:        key,
+		keydownIn:  keydownIn,
+		keydownOut: keydownOut,
+		keyupIn:    keyupIn,
+		keyupOut:   keyupOut,
+	}
+
+	// Make sure the hotkey is unregistered when the created
+	// hotkey is garbage collected.
+	runtime.SetFinalizer(hk, func(x interface{}) {
+		hk := x.(*Hotkey)
+		hk.unregister()
+		close(hk.keydownIn)
+		close(hk.keyupIn)
+	})
+	return hk
 }
 
 // Register registers a combination of hotkeys. If the hotkey has
@@ -49,12 +74,10 @@ func New(mods []Modifier, key Key) *Hotkey {
 func (hk *Hotkey) Register() error { return hk.register() }
 
 // Keydown returns a channel that receives a signal when hotkey is triggered.
-func (hk *Hotkey) Keydown() <-chan Event { return hk.out }
+func (hk *Hotkey) Keydown() <-chan Event { return hk.keydownOut }
 
 // Keyup returns a channel that receives a signal when the hotkey is released.
-func (hk *Hotkey) Keyup() <-chan Event {
-	panic("hotkey: unimplemented")
-}
+func (hk *Hotkey) Keyup() <-chan Event { return hk.keyupOut }
 
 // Unregister unregisters the hotkey.
 func (hk *Hotkey) Unregister() error {
@@ -63,14 +86,23 @@ func (hk *Hotkey) Unregister() error {
 		return err
 	}
 
-	// Setup a new event channel.
-	close(hk.in)
-	in, out := newEventChan()
-	hk.in = in
-	hk.out = out
+	// Reset a new event channel.
+	close(hk.keydownIn)
+	close(hk.keyupIn)
+	hk.keydownIn, hk.keydownOut = newEventChan()
+	hk.keyupIn, hk.keyupOut = newEventChan()
 	return nil
 }
 
+// String returns a string representation of the hotkey.
+func (hk *Hotkey) String() string {
+	s := fmt.Sprintf("%v", hk.key)
+	for _, mod := range hk.mods {
+		s += fmt.Sprintf("+%v", mod)
+	}
+	return s
+}
+
 // newEventChan returns a sender and a receiver of a buffered channel
 // with infinite capacity.
 func newEventChan() (chan<- Event, <-chan Event) {

hotkey_darwin.go

@@ -44,7 +44,7 @@ func (hk *Hotkey) register() error {
 	// A cgo handle could ran out of space, but since in hotkey purpose
 	// we won't have that much number of hotkeys. So this should be fine.
 
-	h := cgo.NewHandle(hk.in)
+	h := cgo.NewHandle(hk.keydownIn)
 	var mod Modifier
 	for _, m := range hk.mods {
 		mod += m

hotkey_linux.go

@@ -96,7 +96,7 @@ func (hk *Hotkey) handle() {
 			if ret != 0 {
 				continue
 			}
-			hk.in <- Event{}
+			hk.keydownIn <- Event{}
 		}
 	}
 }

hotkey_windows.go

@@ -9,11 +9,11 @@
 package hotkey
 
 import (
-	"context"
 	"errors"
 	"runtime"
 	"sync"
 	"sync/atomic"
+	"time"
 
 	"golang.design/x/hotkey/internal/win"
 )
@@ -22,8 +22,7 @@ type platformHotkey struct {
 	mu         sync.Mutex
 	hotkeyId   uint64
 	registered bool
-	ctx        context.Context
-	cancel     context.CancelFunc
+	funcs      chan func()
 	canceled   chan struct{}
 }
 
@@ -36,24 +35,36 @@ func (hk *Hotkey) register() error {
 	hk.mu.Lock()
 	if hk.registered {
 		hk.mu.Unlock()
-		return errors.New("hotkey already registered.")
+		return errors.New("hotkey already registered")
 	}
+
 	mod := uint8(0)
 	for _, m := range hk.mods {
 		mod = mod | uint8(m)
 	}
 
 	hk.hotkeyId = atomic.AddUint64(&hotkeyId, 1)
-	ok, err := win.RegisterHotKey(0, uintptr(hk.hotkeyId), uintptr(mod), uintptr(hk.key))
+	hk.funcs = make(chan func())
+	hk.canceled = make(chan struct{})
+	go hk.handle()
+
+	var (
+		ok   bool
+		err  error
+		done = make(chan struct{})
+	)
+	hk.funcs <- func() {
+		ok, err = win.RegisterHotKey(0, uintptr(hk.hotkeyId), uintptr(mod), uintptr(hk.key))
+		done <- struct{}{}
+	}
+	<-done
 	if !ok {
+		close(hk.canceled)
+		hk.mu.Unlock()
 		return err
 	}
 	hk.registered = true
-	hk.ctx, hk.cancel = context.WithCancel(context.Background())
-	hk.canceled = make(chan struct{})
 	hk.mu.Unlock()
-
-	go hk.handle()
 	return nil
 }
 
@@ -64,34 +75,64 @@ func (hk *Hotkey) unregister() error {
 	if !hk.registered {
 		return errors.New("hotkey is not registered")
 	}
-	hk.cancel()
+
+	done := make(chan struct{})
+	hk.funcs <- func() {
+		win.UnregisterHotKey(0, uintptr(hk.hotkeyId))
+		done <- struct{}{}
+		close(hk.canceled)
+	}
+	<-done
+
 	<-hk.canceled
 	hk.registered = false
 	return nil
 }
 
-// msgHotkey represents hotkey message
-const msgHotkey uint32 = 0x0312
+const (
+	// wmHotkey represents hotkey message
+	wmHotkey uint32 = 0x0312
+	wmQuit   uint32 = 0x0012
+)
 
 // handle handles the hotkey event loop.
 func (hk *Hotkey) handle() {
+	// We could optimize this. So far each hotkey is served in an
+	// individual thread. If we have too many hotkeys, then a program
+	// have to create too many threads to serve them.
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	msg := win.MSG{}
-	// KNOWN ISSUE: This message loop need to press an additional
-	// hotkey to eventually return if ctx.Done() is ready.
-	for win.GetMessage(&msg, 0, 0, 0) {
-		switch msg.Message {
-		case msgHotkey:
+	tk := time.NewTicker(time.Second / 100)
+	for range tk.C {
+		msg := win.MSG{}
+		if !win.PeekMessage(&msg, 0, 0, 0) {
 			select {
-			case <-hk.ctx.Done():
-				win.UnregisterHotKey(0, uintptr(hk.hotkeyId))
-				close(hk.canceled)
+			case f := <-hk.funcs:
+				f()
+			case <-hk.canceled:
 				return
 			default:
-				hk.in <- Event{}
 			}
+			continue
+		}
+		if !win.GetMessage(&msg, 0, 0, 0) {
+			return
+		}
+
+		switch msg.Message {
+		case wmHotkey:
+			hk.keydownIn <- Event{}
+
+			tk := time.NewTicker(time.Second / 100)
+			for range tk.C {
+				if win.GetAsyncKeyState(int(hk.key)) == 0 {
+					hk.keyupIn <- Event{}
+					break
+				}
+			}
+		case wmQuit:
+			return
 		}
 	}
 }

internal/win/hotkey.go

@@ -19,7 +19,10 @@ var (
 	registerHotkey   = user32.NewProc("RegisterHotKey")
 	unregisterHotkey = user32.NewProc("UnregisterHotKey")
 	getMessage       = user32.NewProc("GetMessageW")
+	peekMessage      = user32.NewProc("PeekMessageA")
 	sendMessage      = user32.NewProc("SendMessageW")
+	getAsyncKeyState = user32.NewProc("GetAsyncKeyState")
+	quitMessage      = user32.NewProc("PostQuitMessage")
 )
 
 // RegisterHotKey defines a system-wide hot key.
@@ -87,3 +90,33 @@ func GetMessage(msg *MSG, hWnd uintptr, msgFilterMin, msgFilterMax uint32) bool
 
 	return ret != 0
 }
+
+// PeekMessage dispatches incoming sent messages, checks the thread message
+// queue for a posted message, and retrieves the message (if any exist).
+//
+// https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-peekmessagea
+func PeekMessage(msg *MSG, hWnd uintptr, msgFilterMin, msgFilterMax uint32) bool {
+	ret, _, _ := peekMessage.Call(
+		uintptr(unsafe.Pointer(msg)),
+		hWnd,
+		uintptr(msgFilterMin),
+		uintptr(msgFilterMax),
+		0, // PM_NOREMOVE
+	)
+
+	return ret != 0
+}
+
+// PostQuitMessage indicates to the system that a thread has made
+// a request to terminate (quit). It is typically used in response
+// to a WM_DESTROY message.
+//
+// https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-postquitmessage
+func PostQuitMessage(exitCode int) {
+	quitMessage.Call(uintptr(exitCode))
+}
+
+func GetAsyncKeyState(keycode int) uintptr {
+	ret, _, _ := getAsyncKeyState.Call(uintptr(keycode))
+	return ret
+}