all: allow unregister hotkeys (darwin)

Updates #5, #7

Author: changkun

README.md

@@ -21,7 +21,7 @@ keys is not supported at the moment. Furthermore, because of OS
 restriction, hotkey events must be handled on the main thread.
 
 Therefore, in order to use this package properly, here is a complete
-example that corporates the [mainthread](https://golang.design/s/mainthread)
+example that corporates the mainthread:
 package:
 
 ```go
@@ -31,29 +31,28 @@ import (
 	"context"
 
 	"golang.design/x/hotkey"
-	"golang.design/x/mainthread"
+	"golang.design/x/hotkey/mainthread"
 )
 
 // initialize mainthread facility so that hotkey can be
 // properly registered to the system and handled by the
 // application.
-func main() { mainthread.Init(fn) }
+func main() { mainthread.Run(fn) }
 func fn() { // Use fn as the actual main function.
 	var (
-		mods = []hotkey.Modifier{hotkey.ModCtrl}
+		mods = []hotkey.Modifier{hotkey.ModCtrl, hotkey.ModShift}
 		k    = hotkey.KeyS
 	)
 
 	// Register a desired hotkey.
-	hk, err := hotkey.Register(mods, k)
-	if err != nil {
+	hk := hotkey.New(mods, k)
+	if err := hk.Register() err != nil {
 		panic("hotkey registration failed")
 	}
 
 	// Start listen hotkey event whenever you feel it is ready.
-	triggered := hk.Listen(context.Background())
-	for range triggered {
-		println("hotkey ctrl+s is triggered")
+	for range hk.Listen() {
+		println("hotkey ctrl+shift+s is triggered")
 	}
 }
 ```

example/example

@@ -5,26 +5,43 @@
 package main
 
 import (
-	"context"
+	"time"
 
 	"golang.design/x/hotkey"
-	"golang.design/x/mainthread"
+	"golang.design/x/hotkey/mainthread"
 )
 
-func main() { mainthread.Init(fn) }
+func main() { mainthread.Run(fn) }
 func fn() {
-	var (
-		mods = []hotkey.Modifier{hotkey.ModCtrl}
-		k    = hotkey.KeyS
-	)
-
-	hk, err := hotkey.Register(mods, k)
-	if err != nil {
-		panic("hotkey registration failed")
-	}
-
-	triggered := hk.Listen(context.Background())
-	for range triggered {
-		println("hotkey ctrl+s is triggered")
-	}
+	hk1 := hotkey.New([]hotkey.Modifier{hotkey.ModCtrl}, hotkey.KeyS)
+	go func() {
+		println("register")
+		if err := hk1.Register(); err != nil {
+			panic(err)
+		}
+		for range hk1.Listen() {
+			println("hotkey ctrl+s is triggered")
+		}
+	}()
+
+	<-time.After(5 * time.Second)
+	hk1.Unregister()
+	println("unregistered")
+
+	<-time.After(5 * time.Second)
+	go func() {
+		println("register again")
+		if err := hk1.Register(); err != nil {
+			panic(err)
+		}
+		for range hk1.Listen() {
+			println("hotkey ctrl+s is triggered")
+		}
+	}()
+
+	<-time.After(5 * time.Second)
+	hk1.Unregister()
+	println("unregistered again")
+
+	println("done")
 }

example/main.go

@@ -1,8 +1,3 @@
 module golang.design/x/hotkey
 
 go 1.17
-
-require (
-	golang.design/x/mainthread v0.3.0
-	golang.org/x/sys v0.0.0-20210122093101-04d7465088b8 // indirect
-)

go.mod

@@ -1,5 +0,0 @@
-golang.design/x/mainthread v0.3.0 h1:UwFus0lcPodNpMOGoQMe87jSFwbSsEY//CA7yVmu4j8=
-golang.design/x/mainthread v0.3.0/go.mod h1:vYX7cF2b3pTJMGM/hc13NmN6kblKnf4/IyvHeu259L0=
-golang.org/x/sys v0.0.0-20201022201747-fb209a7c41cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210122093101-04d7465088b8 h1:de2yTH1xuxjmGB7i6Z5o2z3RCHVa0XlpSZzjd8Fe6bE=
-golang.org/x/sys v0.0.0-20210122093101-04d7465088b8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

go.sum

@@ -12,85 +12,83 @@
 // restriction, hotkey events must be handled on the main thread.
 //
 // Therefore, in order to use this package properly, here is a complete
-// example that corporates the golang.design/x/mainthread package:
+// example that corporates the golang.design/x/hotkey/mainthread package:
 //
 // 	package main
 //
 // 	import (
 // 		"context"
 //
 // 		"golang.design/x/hotkey"
-// 		"golang.design/x/mainthread"
+// 		"golang.design/x/hotkey/mainthread"
 // 	)
 //
 // 	// initialize mainthread facility so that hotkey can be
 // 	// properly registered to the system and handled by the
 // 	// application.
-// 	func main() { mainthread.Init(fn) }
+// 	func main() { mainthread.Run(fn) }
 // 	func fn() { // Use fn as the actual main function.
 // 		var (
-// 			mods = []hotkey.Modifier{hotkey.ModCtrl}
+// 			mods = []hotkey.Modifier{hotkey.ModCtrl, hotkey.ModShift}
 // 			k    = hotkey.KeyS
 // 		)
 //
 // 		// Register a desired hotkey.
-// 		hk, err := hotkey.Register(mods, k)
-// 		if err != nil {
+// 		hk := hotkey.New(mods, k)
+// 		if err := hk.Register(); err != nil {
 // 			panic("hotkey registration failed")
 // 		}
 //
 // 		// Start listen hotkey event whenever you feel it is ready.
-// 		triggered := hk.Listen(context.Background())
-// 		for range triggered {
-// 			println("hotkey ctrl+s is triggered")
+// 		for range hk.Listen() {
+// 			println("hotkey ctrl+shift+s is triggered")
 // 		}
 // 	}
 package hotkey
 
-import (
-	"context"
-	"runtime"
-
-	"golang.design/x/mainthread"
-)
-
 // Event represents a hotkey event
 type Event struct{}
 
 // Hotkey is a combination of modifiers and key to trigger an event
 type Hotkey struct {
+	platformHotkey
+
 	mods []Modifier
 	key  Key
 
 	in  chan<- Event
 	out <-chan Event
 }
 
+func New(mods []Modifier, key Key) *Hotkey {
+	in, out := newEventChan()
+	return &Hotkey{mods: mods, key: key, in: in, out: out}
+}
+
 // Register registers a combination of hotkeys. If the hotkey has
 // registered. This function will invalidates the old registration
 // and overwrites its callback.
-func Register(mods []Modifier, key Key) (*Hotkey, error) {
-	in, out := newEventChan()
-	hk := &Hotkey{mods, key, in, out}
-
-	var err error
-	mainthread.Call(func() { err = hk.register() })
-	if err != nil {
-		return nil, err
-	}
-
-	runtime.SetFinalizer(hk, func(hk *Hotkey) {
-		hk.unregister()
-	})
-
-	return hk, nil
+func (hk *Hotkey) Register() error {
+	return hk.register()
 }
 
 // Listen handles a hotkey event and triggers a call to fn.
 // The hotkey listen hook terminates when the context is canceled.
-func (hk *Hotkey) Listen(ctx context.Context) <-chan Event {
-	mainthread.Go(func() { hk.handle(ctx) })
-	return hk.out
+func (hk *Hotkey) Listen() <-chan Event { return hk.out }
+
+// Unregister unregisters the hotkey.
+func (hk *Hotkey) Unregister() error {
+	err := hk.unregister()
+	if err != nil {
+		return err
+	}
+
+	// Setup a new event channel.
+	close(hk.in)
+	in, out := newEventChan()
+	hk.in = in
+	hk.out = out
+	return nil
 }
 
 // newEventChan returns a sender and a receiver of a buffered channel

hotkey.go

@@ -16,25 +16,32 @@ package hotkey
 #import <Carbon/Carbon.h>
 
 extern void hotkeyCallback(uintptr_t handle);
-
-int registerHotKey(int mod, int key, uintptr_t handle);
-void runApp();
-void stopApp();
+int registerHotKey(int mod, int key, uintptr_t handle, EventHotKeyRef* ref);
+int unregisterHotKey(EventHotKeyRef ref);
 */
 import "C"
 import (
-	"context"
 	"errors"
 	"runtime/cgo"
+	"sync"
+
+	"golang.design/x/hotkey/mainthread"
 )
 
-// handle handles the hotkey event loop.
-func (hk *Hotkey) handle(ctx context.Context) {
-	// Note: This call never returns.
-	C.runApp()
+// Hotkey is a combination of modifiers and key to trigger an event
+type platformHotkey struct {
+	mu         sync.Mutex
+	registered bool
+	hkref      C.EventHotKeyRef
 }
 
 func (hk *Hotkey) register() error {
+	hk.mu.Lock()
+	defer hk.mu.Unlock()
+	if hk.registered {
+		return errors.New("hotkey already registered")
+	}
+
 	// Note: we use handle number as hotkey id in the C side.
 	// 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.
@@ -45,18 +52,31 @@ func (hk *Hotkey) register() error {
 		mod += m
 	}
 
-	ret := C.registerHotKey(C.int(mod), C.int(hk.key), C.uintptr_t(h))
+	var ret C.int
+	mainthread.Call(func() {
+		ret = C.registerHotKey(C.int(mod), C.int(hk.key), C.uintptr_t(h), &hk.hkref)
+	})
 	if ret == C.int(-1) {
-		return errors.New("register failed")
+		return errors.New("failed to register the hotkey")
 	}
+
+	hk.registered = true
 	return nil
 }
 
-func (hk *Hotkey) unregister() {
-	// TODO: unregister registered hotkeys.
+func (hk *Hotkey) unregister() error {
+	hk.mu.Lock()
+	defer hk.mu.Unlock()
+	if !hk.registered {
+		return errors.New("hotkey is not registered")
+	}
 
-	// KNOWN ISSUE: This call seems does not terminate the app.
-	C.stopApp()
+	ret := C.unregisterHotKey(hk.hkref)
+	if ret == C.int(-1) {
+		return errors.New("failed to unregister the current hotkey")
+	}
+	hk.registered = false
+	return nil
 }
 
 //export hotkeyCallback

hotkey_darwin.go

@@ -21,7 +21,7 @@
 }
 
 // registerHotkeyWithCallback registers a global system hotkey for callbacks.
-int registerHotKey(int mod, int key, uintptr_t handle) {
+int registerHotKey(int mod, int key, uintptr_t handle, EventHotKeyRef* ref) {
 	EventTypeSpec eventType;
 	eventType.eventClass = kEventClassKeyboard;
 	eventType.eventKind = kEventHotKeyPressed;
@@ -30,27 +30,19 @@ int registerHotKey(int mod, int key, uintptr_t handle) {
 	);
 
 	EventHotKeyID hkid = {.id = handle};
-	EventHotKeyRef ref;
 	OSStatus s = RegisterEventHotKey(
-		key, mod, hkid, GetApplicationEventTarget(), 0, &ref
+		key, mod, hkid, GetApplicationEventTarget(), 0, ref
 	);
 	if (s != noErr) {
 		return -1;
 	}
 	return 0;
 }
 
-
-// The following three lines of code must run on the main thread.
-// It must handle it using golang.design/x/mainthread.
-//
-// inspired from here: https://github.com/cehoffman/dotfiles/blob/4be8e893517e970d40746a9bdc67fe5832dd1c33/os/mac/iTerm2HotKey.m
-void runApp() {
-	[NSApplication sharedApplication];
-	[NSApp disableRelaunchOnLogin];
-	[NSApp run];
+int unregisterHotKey(EventHotKeyRef ref) {
+	OSStatus s = UnregisterEventHotKey(ref);
+	if (s != noErr) {
+		return -1;
+	}
+	return 0;
 }
-
-void stopApp() {
-	[NSApp stop: nil];
-}