add systray menu network selection

Author: peterjah

cmd/massastation/main.go

@@ -81,12 +81,12 @@ func main() {
 
 	pluginManager := plugin.NewManager(configDir)
 
-	stationGUI, systrayMenu := systray.MakeGUI()
 	// Create shared config manager once and inject into server
 	configManager, err := config.GetConfigManager()
 	if err != nil {
 		logger.Fatalf("Failed to initialize config manager: %s", err.Error())
 	}
+	stationGUI, systrayMenu, _ := systray.MakeGUIWithRefresher()
 	server := api.NewServer(serverFlags, configManager)
 
 	update.StartUpdateCheck(&stationGUI, systrayMenu)

int/config/manager.go

@@ -26,11 +26,16 @@ const (
 // ErrNetworkAlreadyExists is returned when trying to add a network with a name that already exists
 var ErrNetworkAlreadyExists = errors.New("network already exists")
 
+// NetworkChangeCallback is a function type called when the network changes.
+type NetworkChangeCallback func()
+
 // MSConfigManager represents a manager for network configurations.
 type MSConfigManager struct {
-	Network     NetworkConfig
-	configMutex sync.RWMutex
-	stopRefresh func()
+	Network            NetworkConfig
+	configMutex       sync.RWMutex
+	stopRefresh       func()
+	onNetworkChange   NetworkChangeCallback
+	networkChangeMutex sync.RWMutex
 }
 
 // NetworkManager is an alias for backward compatibility
@@ -145,12 +150,18 @@ func (n *MSConfigManager) Networks() *[]string {
 	return &options
 }
 
+// SetNetworkChangeCallback sets a callback function that will be called whenever the network changes.
+func (n *MSConfigManager) SetNetworkChangeCallback(callback NetworkChangeCallback) {
+	n.networkChangeMutex.Lock()
+	defer n.networkChangeMutex.Unlock()
+	n.onNetworkChange = callback
+}
+
 // SwitchNetwork switches the current network configuration to the specified network.
 // rpcName: The name of the network configuration to switch to.
 // Returns any error encountered during the switch operation.
 func (n *MSConfigManager) SwitchNetwork(rpcName string) error {
 	n.configMutex.Lock()
-	defer n.configMutex.Unlock()
 
 	// Find the network with the specified name
 	var targetNetwork *RPCInfos
@@ -162,6 +173,7 @@ func (n *MSConfigManager) SwitchNetwork(rpcName string) error {
 	}
 
 	if targetNetwork == nil {
+		n.configMutex.Unlock()
 		return fmt.Errorf("unknown network: %s", rpcName)
 	}
 
@@ -170,6 +182,16 @@ func (n *MSConfigManager) SwitchNetwork(rpcName string) error {
 
 	logger.Debugf("Switched to network: %s", rpcName)
 
+	n.configMutex.Unlock()
+
+	// Call the network change callback if set
+	n.networkChangeMutex.RLock()
+	callback := n.onNetworkChange
+	n.networkChangeMutex.RUnlock()
+	if callback != nil {
+		callback()
+	}
+
 	return nil
 }
 
@@ -277,15 +299,16 @@ func (n *MSConfigManager) SaveConfig(cfg *ConfigFile) error {
 // AddNetwork adds a new network to both memory and persistent configuration
 func (n *MSConfigManager) AddNetwork(name, url string, makeDefault bool) error {
 	n.configMutex.Lock()
-	defer n.configMutex.Unlock()
 
 	if name == "" || url == "" {
+		n.configMutex.Unlock()
 		return fmt.Errorf("name and url are required")
 	}
 
 	// Load current persisted configuration
 	cfg, err := LoadConfig()
 	if err != nil {
+		n.configMutex.Unlock()
 		return fmt.Errorf("load config: %w", err)
 	}
 
@@ -297,6 +320,7 @@ func (n *MSConfigManager) AddNetwork(name, url string, makeDefault bool) error {
 	nameLower := strings.ToLower(strings.TrimSpace(name))
 	for existingName := range cfg.Networks {
 		if strings.ToLower(strings.TrimSpace(existingName)) == nameLower {
+			n.configMutex.Unlock()
 			return fmt.Errorf("%w: %s", ErrNetworkAlreadyExists, name)
 		}
 	}
@@ -315,6 +339,7 @@ func (n *MSConfigManager) AddNetwork(name, url string, makeDefault bool) error {
 	}
 
 	if err := saveConfigUnsafe(cfg); err != nil {
+		n.configMutex.Unlock()
 		return err
 	}
 
@@ -334,8 +359,22 @@ func (n *MSConfigManager) AddNetwork(name, url string, makeDefault bool) error {
 	}
 	n.Network.Networks = append(n.Network.Networks, newNet)
 
+	networkChanged := false
 	if makeDefault {
 		n.Network.currentNetwork = &n.Network.Networks[len(n.Network.Networks)-1]
+		networkChanged = true
+	}
+
+	n.configMutex.Unlock()
+
+	// Call the network change callback if set
+	if networkChanged {
+		n.networkChangeMutex.RLock()
+		callback := n.onNetworkChange
+		n.networkChangeMutex.RUnlock()
+		if callback != nil {
+			callback()
+		}
 	}
 
 	return nil
@@ -346,7 +385,6 @@ func (n *MSConfigManager) AddNetwork(name, url string, makeDefault bool) error {
 // and the current network is switched in memory as well.
 func (n *MSConfigManager) EditNetwork(currentName string, newURL *string, makeDefault *bool, newName *string) error {
 	n.configMutex.Lock()
-	defer n.configMutex.Unlock()
 
 	if currentName == "" {
 		return fmt.Errorf("currentName is required")
@@ -450,10 +488,25 @@ func (n *MSConfigManager) EditNetwork(currentName string, newURL *string, makeDe
 	}
 
 	// Switch current network if default requested or if current was renamed
+	networkChanged := false
 	if makeDefault != nil && *makeDefault {
 		n.Network.currentNetwork = &n.Network.Networks[targetIdx]
+		networkChanged = true
 	} else if n.Network.currentNetwork != nil && n.Network.currentNetwork.Name == currentName && targetName != currentName {
 		n.Network.currentNetwork = &n.Network.Networks[targetIdx]
+		networkChanged = true
+	}
+
+	n.configMutex.Unlock()
+
+	// Call the network change callback if set
+	if networkChanged {
+		n.networkChangeMutex.RLock()
+		callback := n.onNetworkChange
+		n.networkChangeMutex.RUnlock()
+		if callback != nil {
+			callback()
+		}
 	}
 
 	return nil

int/systray/systray.go

@@ -1,36 +1,173 @@
 package systray
 
 import (
+	"sort"
+
 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/app"
 	fyneDesktop "fyne.io/fyne/v2/driver/desktop"
+
 	"github.com/massalabs/station/int/config"
 	"github.com/massalabs/station/int/systray/embedded"
 	"github.com/massalabs/station/int/systray/utils"
 )
 
+// NetworkMenuRefresher holds references needed to refresh the network menu.
+type NetworkMenuRefresher struct {
+	networkMenuItems []*fyne.MenuItem
+	networkSubMenu   *fyne.Menu
+	topLevelMenu     *fyne.Menu
+	desk             fyneDesktop.App
+	cfgMgr           *config.MSConfigManager
+}
+
+// RefreshNetworkMenu updates the checkmarks in the network menu based on the current network.
+func (n *NetworkMenuRefresher) RefreshNetworkMenu() {
+	if n == nil || n.cfgMgr == nil {
+		return
+	}
+
+	current := n.cfgMgr.CurrentNetwork()
+	if current == nil {
+		return
+	}
+
+	// Update checkmarks to reflect the current network.
+	for _, mi := range n.networkMenuItems {
+		mi.Checked = mi.Label == current.Name
+	}
+
+	// Refresh both the submenu and top-level menu to update visual checkmarks.
+	if n.networkSubMenu != nil {
+		n.networkSubMenu.Refresh()
+	}
+	if n.topLevelMenu != nil {
+		n.topLevelMenu.Refresh()
+	}
+	// Also re-set the menu to ensure the system tray updates.
+	if n.desk != nil {
+		n.desk.SetSystemTrayMenu(n.topLevelMenu)
+	}
+}
+
 func MakeGUI() (fyne.App, *fyne.Menu) {
+	stationGUI, _, _ := MakeGUIWithRefresher()
+	return stationGUI, nil
+}
+
+// MakeGUIWithRefresher creates the GUI and returns a refresher for the network menu.
+func MakeGUIWithRefresher() (fyne.App, *fyne.Menu, *NetworkMenuRefresher) {
 	stationGUI := app.New()
 
 	if desk, ok := stationGUI.(fyneDesktop.App); ok {
 		icon := fyne.NewStaticResource("logo", embedded.Logo)
 
+		// Try to load network configuration for the "Network" submenu.
+		var networkSubMenu *fyne.Menu
+		var topLevelMenu *fyne.Menu
+		var refresher *NetworkMenuRefresher
+		var cfgMgr *config.MSConfigManager
+		if mgr, err := config.GetConfigManager(); err == nil && mgr != nil {
+			cfgMgr = mgr
+			current := mgr.CurrentNetwork()
+			var networkMenuItems []*fyne.MenuItem
+
+			// Sort networks alphabetically by name.
+			networks := make([]config.RPCInfos, len(mgr.Network.Networks))
+			copy(networks, mgr.Network.Networks)
+			sort.Slice(networks, func(i, j int) bool {
+				return networks[i].Name < networks[j].Name
+			})
+
+			for _, netInfo := range networks {
+				networkName := netInfo.Name
+
+				item := fyne.NewMenuItem(networkName, nil)
+				if current != nil && current.Name == networkName {
+					item.Checked = true
+				}
+
+				networkMenuItems = append(networkMenuItems, item)
+			}
+
+			// Create the network submenu before setting up actions so closures can reference it.
+			if len(networkMenuItems) > 0 {
+				networkSubMenu = fyne.NewMenu("Network", networkMenuItems...)
+
+				// Create refresher for callback-based updates
+				refresher = &NetworkMenuRefresher{
+					networkMenuItems: networkMenuItems,
+					networkSubMenu:   networkSubMenu,
+					cfgMgr:           mgr,
+				}
+
+				// Now set up the action closures with access to the submenu and desktop app.
+				for i, netInfo := range networks {
+					networkName := netInfo.Name
+					item := networkMenuItems[i]
+
+					// Capture networkName by value in the closure.
+					item.Action = func(name string) func() {
+						return func() {
+							// Switch the backend network.
+							if err := mgr.SwitchNetwork(name); err != nil {
+								// If switching fails, leave the UI unchanged.
+								return
+							}
+
+							// Update checkmarks using the refresher.
+							// Note: The callback will also be triggered, but refreshing here ensures immediate UI update.
+							if refresher != nil {
+								refresher.RefreshNetworkMenu()
+							}
+						}
+					}(networkName)
+				}
+			}
+		}
+
 		homeShortCutMenu := fyne.NewMenuItem("Open MassaStation", nil)
 		homeShortCutMenu.Action = func() {
 			utils.OpenURL(&stationGUI, "https://"+config.MassaStationURL)
 		}
 
-		menu := fyne.NewMenu(
-			"MassaStation",
+		// Build the top-level systray menu in an idiomatic Fyne way.
+		menuItems := []*fyne.MenuItem{
 			fyne.NewMenuItemSeparator(),
 			homeShortCutMenu,
-		)
+		}
+
+		// If we have networks, add a "Network" submenu.
+		if networkSubMenu != nil {
+			networkItem := fyne.NewMenuItem("Network", nil)
+			networkItem.ChildMenu = networkSubMenu
+
+			menuItems = append(
+				menuItems,
+				fyne.NewMenuItemSeparator(),
+				networkItem,
+			)
+		}
+
+		menu := fyne.NewMenu("MassaStation", menuItems...)
+		topLevelMenu = menu
+
+		// Update refresher with top-level menu and desktop app references
+		if refresher != nil && cfgMgr != nil {
+			refresher.topLevelMenu = topLevelMenu
+			refresher.desk = desk
+
+			// Register the refresher callback with the config manager
+			cfgMgr.SetNetworkChangeCallback(func() {
+				refresher.RefreshNetworkMenu()
+			})
+		}
 
 		desk.SetSystemTrayIcon(icon)
 		desk.SetSystemTrayMenu(menu)
 
-		return stationGUI, menu
+		return stationGUI, menu, refresher
 	}
 
-	return stationGUI, nil
+	return stationGUI, nil, nil
 }

web/massastation/src/custom/api/useResource.ts

@@ -2,11 +2,14 @@
 
 // EXTERNALS
 import axios, { AxiosResponse } from 'axios';
-import { useQuery, UseQueryResult } from '@tanstack/react-query';
+import { useQuery, UseQueryResult, UseQueryOptions } from '@tanstack/react-query';
 
 // LOCALS
 
-export function useResource<T>(resource: string): UseQueryResult<T, undefined> {
+export function useResource<T>(
+  resource: string,
+  options?: Omit<UseQueryOptions<T, undefined>, 'queryKey' | 'queryFn'>
+): UseQueryResult<T, undefined> {
   const url = `${import.meta.env.VITE_BASE_API}/${resource}`;
 
   return useQuery<T, undefined>({
@@ -16,5 +19,6 @@ export function useResource<T>(resource: string): UseQueryResult<T, undefined> {
 
       return data;
     },
+    ...options,
   });
 }

web/massastation/src/layouts/LayoutStation/LayoutStation.tsx

@@ -42,8 +42,11 @@ export function LayoutStation(props: LayoutStationProps) {
 
   const navigate = useNavigate();
 
+  // Poll network endpoint every 2 seconds to detect changes from systray
   const { data: network, isSuccess: isSuccessNetwork } =
-    useResource<NetworkModel>(URL.PATH_NETWORKS);
+    useResource<NetworkModel>(URL.PATH_NETWORKS, {
+      refetchInterval: 2000, // Refetch every 2 seconds
+    });
 
   const {currentNetwork, setCurrentNetwork, setAvailableNetworks} = useNetworkStore();