Implement global shortcuts

README.md

@@ -446,6 +446,27 @@ var m = d.NewMenu([]*astilectron.MenuItemOptions{
 m.Create()
 ```
 
+## Global Shortcuts
+
+Registering a global shortcut.
+
+```go
+// Register a new global shortcut
+isRegistered, _ := astilectron.GlobalShortcutRegister("CmdOrCtrl+x", func() {
+    fmt.Println("CmdOrCtrl+x is pressed")
+})
+fmt.Println("CmdOrCtrl+x is registered:", isRegistered)  // true
+
+// Check if a global shortcut is registered
+isRegistered, _ = astilectron.GlobalShortcutIsRegistered("Shift+Y") // false
+
+// Unregister a global shortcut
+astilectron.GlobalShortcutUnregister("CmdOrCtrl+x")
+
+// Unregister all global shortcuts
+astilectron.GlobalShortcutUnregisterAll()
+```
+
 ## Dialogs
 
 Add the following line at the top of your javascript file :

astilectron.go

@@ -2,12 +2,11 @@ package astilectron
 
 import (
 	"fmt"
+	"github.com/asticode/go-astikit"
 	"net"
 	"os/exec"
 	"runtime"
 	"time"
-
-	"github.com/asticode/go-astikit"
 )
 
 // Versions
@@ -41,22 +40,23 @@ const (
 
 // Astilectron represents an object capable of interacting with Astilectron
 type Astilectron struct {
-	dispatcher   *dispatcher
-	displayPool  *displayPool
-	dock         *Dock
-	executer     Executer
-	identifier   *identifier
-	l            astikit.SeverityLogger
-	listener     net.Listener
-	options      Options
-	paths        *Paths
-	provisioner  Provisioner
-	reader       *reader
-	stderrWriter *astikit.WriterAdapter
-	stdoutWriter *astikit.WriterAdapter
-	supported    *Supported
-	worker       *astikit.Worker
-	writer       *writer
+	dispatcher      *dispatcher
+	displayPool     *displayPool
+	dock            *Dock
+	executer        Executer
+	globalShortcuts *GlobalShortcuts
+	identifier      *identifier
+	l               astikit.SeverityLogger
+	listener        net.Listener
+	options         Options
+	paths           *Paths
+	provisioner     Provisioner
+	reader          *reader
+	stderrWriter    *astikit.WriterAdapter
+	stdoutWriter    *astikit.WriterAdapter
+	supported       *Supported
+	worker          *astikit.Worker
+	writer          *writer
 }
 
 // Options represents Astilectron options
@@ -156,6 +156,11 @@ func (a *Astilectron) SetExecuter(e Executer) *Astilectron {
 	return a
 }
 
+// GlobalShortcuts gets the global shortcuts
+func (a *Astilectron) GlobalShortcuts() *GlobalShortcuts {
+	return a.globalShortcuts
+}
+
 // On implements the Listenable interface
 func (a *Astilectron) On(eventName string, l Listener) {
 	a.dispatcher.addListener(targetIDApp, eventName, l)
@@ -187,6 +192,7 @@ func (a *Astilectron) Start() (err error) {
 	} else {
 		synchronousFunc(a.worker.Context(), a, nil, "app.event.ready")
 	}
+
 	return nil
 }
 
@@ -322,6 +328,9 @@ func (a *Astilectron) executeCmd(cmd *exec.Cmd) (err error) {
 	// Create dock
 	a.dock = newDock(a.worker.Context(), a.dispatcher, a.identifier, a.writer)
 
+	// Create global shortcuts
+	a.globalShortcuts = newGlobalShortcuts(a.worker.Context(), a.dispatcher, a.identifier, a.writer)
+
 	// Update supported features
 	a.supported = e.Supported
 	return

event.go

@@ -20,39 +20,40 @@ type Event struct {
 	// This is a list of all possible payloads.
 	// A choice was made not to use interfaces since it's a pain in the ass asserting each an every payload afterwards
 	// We use pointers so that omitempty works
-	AuthInfo            *EventAuthInfo       `json:"authInfo,omitempty"`
-	Badge               *string              `json:"badge,omitempty"`
-	BounceType          string               `json:"bounceType,omitempty"`
-	Bounds              *RectangleOptions    `json:"bounds,omitempty"`
-	CallbackID          string               `json:"callbackId,omitempty"`
-	Code                string               `json:"code,omitempty"`
-	Displays            *EventDisplays       `json:"displays,omitempty"`
-	Enable              *bool                `json:"enable,omitempty"`
-	FilePath            string               `json:"filePath,omitempty"`
-	ID                  *int                 `json:"id,omitempty"`
-	Image               string               `json:"image,omitempty"`
-	Index               *int                 `json:"index,omitempty"`
-	Menu                *EventMenu           `json:"menu,omitempty"`
-	MenuItem            *EventMenuItem       `json:"menuItem,omitempty"`
-	MenuItemOptions     *MenuItemOptions     `json:"menuItemOptions,omitempty"`
-	MenuItemPosition    *int                 `json:"menuItemPosition,omitempty"`
-	MenuPopupOptions    *MenuPopupOptions    `json:"menuPopupOptions,omitempty"`
-	Message             *EventMessage        `json:"message,omitempty"`
-	NotificationOptions *NotificationOptions `json:"notificationOptions,omitempty"`
-	Password            string               `json:"password,omitempty"`
-	Path                string               `json:"path,omitempty"`
-	Reply               string               `json:"reply,omitempty"`
-	Request             *EventRequest        `json:"request,omitempty"`
-	SecondInstance      *EventSecondInstance `json:"secondInstance,omitempty"`
-	SessionID           string               `json:"sessionId,omitempty"`
-	Supported           *Supported           `json:"supported,omitempty"`
-	TrayOptions         *TrayOptions         `json:"trayOptions,omitempty"`
-	URL                 string               `json:"url,omitempty"`
-	URLNew              string               `json:"newUrl,omitempty"`
-	URLOld              string               `json:"oldUrl,omitempty"`
-	Username            string               `json:"username,omitempty"`
-	WindowID            string               `json:"windowId,omitempty"`
-	WindowOptions       *WindowOptions       `json:"windowOptions,omitempty"`
+	AuthInfo            *EventAuthInfo        `json:"authInfo,omitempty"`
+	Badge               *string               `json:"badge,omitempty"`
+	BounceType          string                `json:"bounceType,omitempty"`
+	Bounds              *RectangleOptions     `json:"bounds,omitempty"`
+	CallbackID          string                `json:"callbackId,omitempty"`
+	Code                string                `json:"code,omitempty"`
+	Displays            *EventDisplays        `json:"displays,omitempty"`
+	Enable              *bool                 `json:"enable,omitempty"`
+	FilePath            string                `json:"filePath,omitempty"`
+	GlobalShortcuts     *EventGlobalShortcuts `json:"globalShortcuts,omitempty"`
+	ID                  *int                  `json:"id,omitempty"`
+	Image               string                `json:"image,omitempty"`
+	Index               *int                  `json:"index,omitempty"`
+	Menu                *EventMenu            `json:"menu,omitempty"`
+	MenuItem            *EventMenuItem        `json:"menuItem,omitempty"`
+	MenuItemOptions     *MenuItemOptions      `json:"menuItemOptions,omitempty"`
+	MenuItemPosition    *int                  `json:"menuItemPosition,omitempty"`
+	MenuPopupOptions    *MenuPopupOptions     `json:"menuPopupOptions,omitempty"`
+	Message             *EventMessage         `json:"message,omitempty"`
+	NotificationOptions *NotificationOptions  `json:"notificationOptions,omitempty"`
+	Password            string                `json:"password,omitempty"`
+	Path                string                `json:"path,omitempty"`
+	Reply               string                `json:"reply,omitempty"`
+	Request             *EventRequest         `json:"request,omitempty"`
+	SecondInstance      *EventSecondInstance  `json:"secondInstance,omitempty"`
+	SessionID           string                `json:"sessionId,omitempty"`
+	Supported           *Supported            `json:"supported,omitempty"`
+	TrayOptions         *TrayOptions          `json:"trayOptions,omitempty"`
+	URL                 string                `json:"url,omitempty"`
+	URLNew              string                `json:"newUrl,omitempty"`
+	URLOld              string                `json:"oldUrl,omitempty"`
+	Username            string                `json:"username,omitempty"`
+	WindowID            string                `json:"windowId,omitempty"`
+	WindowOptions       *WindowOptions        `json:"windowOptions,omitempty"`
 }
 
 // EventAuthInfo represents an event auth info
@@ -70,6 +71,12 @@ type EventDisplays struct {
 	Primary *DisplayOptions   `json:"primary,omitempty"`
 }
 
+// EventGlobalShortcuts represents event global shortcuts
+type EventGlobalShortcuts struct {
+	Accelerator  string `json:"accelerator,omitempty"`
+	IsRegistered bool   `json:"isRegistered,omitempty"`
+}
+
 // EventMessage represents an event message
 type EventMessage struct {
 	i interface{}

global_shortcuts.go

@@ -0,0 +1,135 @@
+package astilectron
+
+import (
+	"context"
+	"sync"
+)
+
+const (
+	EventNameGlobalShortcutsCmdRegister          = "global.shortcuts.cmd.register"
+	EventNameGlobalShortcutsCmdIsRegistered      = "global.shortcuts.cmd.is.register"
+	EventNameGlobalShortcutsCmdUnregister        = "global.shortcuts.cmd.unregister"
+	EventNameGlobalShortcutsCmdUnregisterAll     = "global.shortcuts.cmd.unregister.all"
+	EventNameGlobalShortcutsEventRegistered      = "global.shortcuts.event.registered"
+	EventNameGlobalShortcutsEventIsRegistered    = "global.shortcuts.event.is.registered"
+	EventNameGlobalShortcutsEventUnregistered    = "global.shortcuts.event.unregistered"
+	EventNameGlobalShortcutsEventUnregisteredAll = "global.shortcuts.event.unregistered.all"
+	EventNameGlobalShortcutEventTriggered        = "global.shortcuts.event.triggered"
+)
+
+type globalShortcutsCallback func()
+
+// GlobalShortcuts represents a global shortcut
+type GlobalShortcuts struct {
+	*object
+	m         *sync.Mutex
+	callbacks map[string]*globalShortcutsCallback // Store all registered Global Shortcuts
+}
+
+func newGlobalShortcuts(ctx context.Context, d *dispatcher, i *identifier, w *writer) (gs *GlobalShortcuts) {
+
+	gs = &GlobalShortcuts{object: newObject(ctx, d, i, w, i.new()), m: new(sync.Mutex), callbacks: make(map[string]*globalShortcutsCallback)}
+	gs.On(EventNameGlobalShortcutEventTriggered, func(e Event) (deleteListener bool) { // Register the listener for the triggered event
+		gs.execCallback(e.GlobalShortcuts.Accelerator)
+		return
+	})
+	return
+}
+
+// Register Register global shortcuts
+func (gs *GlobalShortcuts) Register(accelerator string, callback globalShortcutsCallback) (isRegistered bool, err error) {
+
+	if err = gs.ctx.Err(); err != nil {
+		return
+	}
+
+	// Send an event to astilectron to register the global shortcut
+	var event = Event{Name: EventNameGlobalShortcutsCmdRegister, TargetID: gs.id, GlobalShortcuts: &EventGlobalShortcuts{Accelerator: accelerator}}
+	result, err := synchronousEvent(gs.ctx, gs, gs.w, event, EventNameGlobalShortcutsEventRegistered)
+
+	if err != nil {
+		return
+	}
+
+	// If registered successfully, add the callback to the map
+	if result.GlobalShortcuts.IsRegistered {
+		gs.m.Lock()
+		gs.callbacks[accelerator] = &callback
+		gs.m.Unlock()
+	}
+
+	isRegistered = result.GlobalShortcuts.IsRegistered
+	return
+}
+
+// IsRegistered Check if a global shortcut is registered
+func (gs *GlobalShortcuts) IsRegistered(accelerator string) (isRegistered bool, err error) {
+
+	if err = gs.ctx.Err(); err != nil {
+		return
+	}
+
+	// Send an event to astilectron to check if global shortcut is registered
+	var event = Event{Name: EventNameGlobalShortcutsCmdIsRegistered, TargetID: gs.id, GlobalShortcuts: &EventGlobalShortcuts{Accelerator: accelerator}}
+	result, err := synchronousEvent(gs.ctx, gs, gs.w, event, EventNameGlobalShortcutsEventIsRegistered)
+
+	if err != nil {
+		return
+	}
+
+	isRegistered = result.GlobalShortcuts.IsRegistered
+	return
+}
+
+// Unregister Unregister a global shortcut
+func (gs *GlobalShortcuts) Unregister(accelerator string) (err error) {
+
+	if err = gs.ctx.Err(); err != nil {
+		return
+	}
+
+	// Send an event to astilectron to unregister the global shortcut
+	var event = Event{Name: EventNameGlobalShortcutsCmdUnregister, TargetID: gs.id, GlobalShortcuts: &EventGlobalShortcuts{Accelerator: accelerator}}
+	_, err = synchronousEvent(gs.ctx, gs, gs.w, event, EventNameGlobalShortcutsEventUnregistered)
+
+	if err != nil {
+		return
+	}
+
+	// No need to find the callback from the map and delete it
+	//  because that event will no longer be triggerred
+	// If the same global shortcut is registered again, the original callback will be replaced with the new one
+
+	return
+}
+
+// UnregisterAll Unregister all global shortcuts
+func (gs *GlobalShortcuts) UnregisterAll() (err error) {
+
+	if err = gs.ctx.Err(); err != nil {
+		return
+	}
+
+	// Send an event to astilectron to unregister all global shortcuts
+	var event = Event{Name: EventNameGlobalShortcutsCmdUnregisterAll, TargetID: gs.id}
+	_, err = synchronousEvent(gs.ctx, gs, gs.w, event, EventNameGlobalShortcutsEventUnregisteredAll)
+
+	if err != nil {
+		return
+	}
+
+	gs.m.Lock()
+	gs.callbacks = make(map[string]*globalShortcutsCallback) // Clear the map
+	gs.m.Unlock()
+
+	return
+}
+
+// execCallback Execute the GlobalShortcuts event triggered from astilectron
+func (gs *GlobalShortcuts) execCallback(accelerator string) {
+	gs.m.Lock()
+	if callback, ok := gs.callbacks[accelerator]; ok {
+		(*callback)()
+	}
+	gs.m.Unlock()
+}

global_shortcuts_test.go

@@ -0,0 +1,42 @@
+package astilectron
+
+import (
+	"context"
+	"fmt"
+	"testing"
+)
+
+func TestGlobalShortcut_Actions(t *testing.T) {
+	var d = newDispatcher()
+	var i = newIdentifier()
+	var wrt = &mockedWriter{}
+	var w = newWriter(wrt, &logger{})
+
+	var gs = newGlobalShortcuts(context.Background(), d, i, w)
+
+	// Register
+	testObjectAction(t, func() error {
+		_, e := gs.Register("Ctrl+X", func() {})
+		return e
+	}, gs.object, wrt, fmt.Sprintf(`{"name":"%s","targetID":"%s","globalShortcuts":{"accelerator":"Ctrl+X"}}%s`, EventNameGlobalShortcutsCmdRegister, gs.id, "\n"),
+		EventNameGlobalShortcutsEventRegistered, &Event{GlobalShortcuts: &EventGlobalShortcuts{Accelerator: "Ctrl+X", IsRegistered: true}})
+
+	// IsRegistered
+	testObjectAction(t, func() error {
+		_, e := gs.IsRegistered("Ctrl+Y")
+		return e
+	}, gs.object, wrt, fmt.Sprintf(`{"name":"%s","targetID":"%s","globalShortcuts":{"accelerator":"Ctrl+Y"}}%s`, EventNameGlobalShortcutsCmdIsRegistered, gs.id, "\n"),
+		EventNameGlobalShortcutsEventIsRegistered, &Event{GlobalShortcuts: &EventGlobalShortcuts{Accelerator: "Ctrl+Y", IsRegistered: false}})
+
+	// Unregister
+	testObjectAction(t, func() error {
+		return gs.Unregister("Ctrl+Z")
+	}, gs.object, wrt, fmt.Sprintf(`{"name":"%s","targetID":"%s","globalShortcuts":{"accelerator":"Ctrl+Z"}}%s`, EventNameGlobalShortcutsCmdUnregister, gs.id, "\n"),
+		EventNameGlobalShortcutsEventUnregistered, nil)
+
+	// UnregisterAll
+	testObjectAction(t, func() error {
+		return gs.UnregisterAll()
+	}, gs.object, wrt, fmt.Sprintf(`{"name":"%s","targetID":"%s"}%s`, EventNameGlobalShortcutsCmdUnregisterAll, gs.id, "\n"),
+		EventNameGlobalShortcutsEventUnregisteredAll, nil)
+}