Develop

Directory.Build.props

@@ -0,0 +1,14 @@
+<Project>
+  <!--
+    The .NET SDK does NOT emit a combined "NET10_0_WINDOWS" preprocessor symbol for the
+    net10.0-windows target framework — it defines NET10_0, WINDOWS, WINDOWS7_0, etc.
+    This codebase gates all Windows-only code (radio/audio modes, device enumeration,
+    the tune meter, WPF) with #if NET10_0_WINDOWS, so without this define that code
+    silently compiles out of every build. Define it for the windows TFM across all
+    projects so the Windows-only code actually compiles into the windows build (and
+    stays excluded from the cross-platform net10.0 / Linux / Docker build).
+  -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net10.0-windows'">
+    <DefineConstants>$(DefineConstants);NET10_0_WINDOWS</DefineConstants>
+  </PropertyGroup>
+</Project>

Resgrid.Audio.Core/AudioEvaluator.cs

@@ -8,7 +8,7 @@
 using DtmfDetection.NAudio;
 using NAudio.Wave;
 using Resgrid.Audio.Core.Events;
-using Serilog.Core;
+using Serilog;
 
 namespace Resgrid.Audio.Core
 {
@@ -29,7 +29,7 @@ public interface IAudioEvaluator
 	public class AudioEvaluator : IAudioEvaluator
 	{
 		private static Object _lock = new Object();
-		private readonly Logger _logger;
+		private readonly ILogger _logger;
 
 		private Config _config;
 		private List<DtmfTone> _dtmfTone;
@@ -40,7 +40,7 @@ public class AudioEvaluator : IAudioEvaluator
 		public event EventHandler<EvaluatorEventArgs> EvaluatorFinished;
 		public event EventHandler<WatcherEventArgs> WatcherTriggered;
 
-		public AudioEvaluator(Logger logger)
+		public AudioEvaluator(ILogger logger)
 		{
 			_logger = logger;
 

Resgrid.Audio.Core/Radio/RadioBridge.cs

@@ -136,10 +136,18 @@ private void OnRadioAudio(object sender, short[] frame)
 			_emergency?.Process(frame);
 
 			bool open = IsSquelchOpen(frame);
-			SetReceiving(open);
 
+			// Only count as "receiving" when RX audio is actually forwarded to the channel —
+			// not merely when squelch opens, and not while AntiLoop suppresses forwarding during
+			// transmit (a squelch opening then is our own TX feedback, not real RX, and counting
+			// it would make OnChannelAudio's anti-loop gate suppress the in-progress transmit).
 			if (!open || (_settings.AntiLoop && _transmitting))
+			{
+				SetReceiving(false);
 				return;
+			}
+
+			SetReceiving(true);
 
 			// Copy + condition the audio before publishing.
 			var outgoing = (short[])frame.Clone();

Resgrid.Audio.Core/WatcherAudioStorage.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using Serilog.Core;
+using Serilog;
 
 namespace Resgrid.Audio.Core
 {
@@ -16,10 +16,10 @@ public interface IWatcherAudioStorage
 	public class WatcherAudioStorage : IWatcherAudioStorage
 	{
 		private static Object _lock = new Object();
-		private readonly Logger _logger;
+		private readonly ILogger _logger;
 		private static Dictionary<Guid, List<byte>> _watcherAudio;
 
-		public WatcherAudioStorage(Logger logger)
+		public WatcherAudioStorage(ILogger logger)
 		{
 			_logger = logger;
 			_watcherAudio = new Dictionary<Guid, List<byte>>();

Resgrid.Audio.Relay/App.xaml

@@ -1,6 +1,13 @@
 <Application x:Class="Resgrid.Audio.Relay.App"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             StartupUri="MainWindow.xaml">
-    <Application.Resources />
+             xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ui:ThemesDictionary Theme="Dark" />
+                <ui:ControlsDictionary />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
 </Application>

Resgrid.Audio.Relay/App.xaml.cs

@@ -1,8 +1,145 @@
-using System.Windows;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Windows;
+using Microsoft.Extensions.DependencyInjection;
+using Resgrid.Audio.Relay.Services;
+using Resgrid.Audio.Relay.ViewModels;
+using Resgrid.Audio.Relay.Views;
+using Resgrid.Relay.Engine;
+using Resgrid.Relay.Engine.Logging;
+using Serilog;
+using Wpf.Ui.Appearance;
 
 namespace Resgrid.Audio.Relay
 {
+	/// <summary>
+	/// Application entry point. Owns the single-instance guard, the DI container, theme
+	/// application and the start-to-tray vs start-visible decision. The engine is composed via
+	/// <see cref="ServiceCollectionExtensions.AddRelayEngine"/>; logging is fanned out to a
+	/// <see cref="UiLogBus"/> for the Logs screen.
+	/// </summary>
 	public partial class App : Application
 	{
+		private const string SingleInstanceMutexName = "Global\\ResgridRelayDesktop";
+
+		private Mutex _singleInstanceMutex;
+		private ServiceProvider _services;
+
+		/// <summary>Process-wide service provider, exposed for XAML-created view-models if needed.</summary>
+		public static IServiceProvider Services { get; private set; }
+
+		protected override void OnStartup(StartupEventArgs e)
+		{
+			base.OnStartup(e);
+
+			// (1) Single-instance guard — surface the existing instance instead of starting twice.
+			_singleInstanceMutex = new Mutex(initiallyOwned: true, SingleInstanceMutexName, out var createdNew);
+			if (!createdNew)
+			{
+				MessageBox.Show(
+					"Resgrid Relay is already running.",
+					"Resgrid Relay",
+					MessageBoxButton.OK,
+					MessageBoxImage.Information);
+				Shutdown();
+				return;
+			}
+
+			// (2) Build the DI container.
+			_services = BuildServiceProvider();
+			Services = _services;
+
+			// (3) Apply the WPF-UI theme.
+			ApplicationThemeManager.Apply(ApplicationTheme.Dark);
+
+			// (4) Resolve the shell. Start hidden to tray when launched with --minimized.
+			var startMinimized = e.Args.Any(a =>
+				string.Equals(a, "--minimized", StringComparison.OrdinalIgnoreCase) ||
+				string.Equals(a, "/minimized", StringComparison.OrdinalIgnoreCase));
+
+			var shell = _services.GetRequiredService<ShellWindow>();
+			MainWindow = shell;
+
+			if (startMinimized)
+			{
+				// Stay hidden — the tray icon (created with the window) keeps the app alive.
+				shell.StartHiddenToTray();
+			}
+			else
+			{
+				shell.Show();
+			}
+		}
+
+		private static ServiceProvider BuildServiceProvider()
+		{
+			var services = new ServiceCollection();
+
+			// Engine (per-mode service factory delegate).
+			services.AddRelayEngine();
+
+			// UI log bus + a Serilog logger fanned out to it (plus Debug for local diagnostics).
+			var logBus = new UiLogBus();
+			services.AddSingleton(logBus);
+
+			ILogger logger = new LoggerConfiguration()
+				.MinimumLevel.Information()
+				.WriteTo.UiBus(logBus)
+				.CreateLogger();
+			services.AddSingleton(logger);
+			Log.Logger = logger;
+
+			// App services.
+			services.AddSingleton<ConfigurationService>();
+			services.AddSingleton<DeviceEnumerationService>();
+			services.AddSingleton<RelayController>();
+
+			// View-models.
+			services.AddSingleton<ShellViewModel>();
+			services.AddTransient<DashboardViewModel>();
+			services.AddTransient<OperationsViewModel>();
+			services.AddTransient<ConfigurationViewModel>();
+			// Singleton: owns a long-lived log pump consuming the singleton UiLogBus and must survive
+			// navigation (so logs aren't lost and a reused LogsView page keeps working). Disposed by
+			// the container at app shutdown.
+			services.AddSingleton<LogsViewModel>();
+			services.AddTransient<DevicesViewModel>();
+			services.AddTransient<AboutViewModel>();
+
+			// Views.
+			services.AddTransient<DashboardView>();
+			services.AddTransient<OperationsView>();
+			services.AddTransient<ConfigurationView>();
+			services.AddTransient<LogsView>();
+			services.AddTransient<DevicesView>();
+			services.AddTransient<AboutView>();
+
+			// Shell window.
+			services.AddSingleton<ShellWindow>();
+
+			return services.BuildServiceProvider();
+		}
+
+		protected override void OnExit(ExitEventArgs e)
+		{
+			try
+			{
+				// Relay modes are stopped in the explicit quit flow (ShellWindow) before
+				// Shutdown(); OnExit now only disposes and flushes synchronously so it always
+				// runs to completion (an async-void OnExit could return before cleanup ran).
+				_services?.Dispose();
+			}
+			catch
+			{
+				// Best-effort shutdown — never block process exit.
+			}
+			finally
+			{
+				Log.CloseAndFlush();
+				_singleInstanceMutex?.Dispose();
+				base.OnExit(e);
+			}
+		}
 	}
 }

Resgrid.Audio.Relay/Controls/LevelMeter.xaml

@@ -0,0 +1,21 @@
+<UserControl x:Class="Resgrid.Audio.Relay.Controls.LevelMeter"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             mc:Ignorable="d"
+             x:Name="Root"
+             d:DesignHeight="20" d:DesignWidth="200">
+    <Grid>
+        <ProgressBar x:Name="Bar"
+                     Minimum="0" Maximum="100"
+                     Height="14"
+                     Foreground="#2ECC71"
+                     Background="#22000000" />
+        <TextBlock x:Name="Label"
+                   HorizontalAlignment="Center"
+                   VerticalAlignment="Center"
+                   FontSize="10"
+                   Foreground="#DDFFFFFF" />
+    </Grid>
+</UserControl>

Resgrid.Audio.Relay/Controls/LevelMeter.xaml.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+
+namespace Resgrid.Audio.Relay.Controls
+{
+	/// <summary>
+	/// A simple input-level meter that maps a dBFS value (typically -80..0) onto a 0..100
+	/// <see cref="ProgressBar"/> using <c>(db + 80) / 80</c>, and shows the numeric value.
+	/// </summary>
+	public partial class LevelMeter : UserControl
+	{
+		public LevelMeter()
+		{
+			InitializeComponent();
+			UpdateVisual(Dbfs);
+		}
+
+		public static readonly DependencyProperty DbfsProperty = DependencyProperty.Register(
+			nameof(Dbfs),
+			typeof(double),
+			typeof(LevelMeter),
+			new FrameworkPropertyMetadata(-80.0, OnDbfsChanged));
+
+		/// <summary>Current input level in dBFS. Clamped to the -80..0 display range.</summary>
+		public double Dbfs
+		{
+			get => (double)GetValue(DbfsProperty);
+			set => SetValue(DbfsProperty, value);
+		}
+
+		private static void OnDbfsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+		{
+			((LevelMeter)d).UpdateVisual((double)e.NewValue);
+		}
+
+		private void UpdateVisual(double db)
+		{
+			// Clamp to the -80..0 display range once, then map to a 0..100 percentage
+			// (-80 dBFS -> 0, 0 dBFS -> 100) so the bar and the label stay consistent.
+			var clampedDb = Math.Clamp(db, -80.0, 0.0);
+			Bar.Value = (clampedDb + 80.0) / 80.0 * 100.0;
+			Label.Text = $"{clampedDb,5:0.0} dBFS";
+		}
+	}
+}