Add application icon resources and set as project icon

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

WirelessTextSyncer.Windows.Tests/SyncMessageTests.cs

@@ -59,6 +59,21 @@ public sealed class SyncMessageTests
             keyboard.Calls);
     }
 
+    [TestMethod]
+    public void DiscoveryResponseContainsServiceEndpoint()
+    {
+        using var discovery = new DiscoveryResponderService(() => "192.168.1.10", () => 8181, "Desktop-WIN11");
+
+        using var document = JsonDocument.Parse(discovery.BuildResponseJson());
+        var root = document.RootElement;
+
+        Assert.AreEqual("wirelessTextSyncer.service", root.GetProperty("type").GetString());
+        Assert.AreEqual(1, root.GetProperty("version").GetInt32());
+        Assert.AreEqual("Desktop-WIN11", root.GetProperty("name").GetString());
+        Assert.AreEqual("192.168.1.10", root.GetProperty("host").GetString());
+        Assert.AreEqual(8181, root.GetProperty("port").GetInt32());
+    }
+
     private sealed class RecordingKeyboardInjectionService : IKeyboardInjectionService
     {
         public List<string> Calls { get; } = [];

WirelessTextSyncer.Windows/Services/DiscoveryResponderService.cs

@@ -0,0 +1,115 @@
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json;
+
+namespace WirelessTextSyncer.Windows.Services;
+
+public sealed class DiscoveryResponderService : IDisposable
+{
+    public const int DiscoveryPort = 8182;
+    public const string DiscoveryRequestType = "wirelessTextSyncer.discovery";
+    public const string ServiceResponseType = "wirelessTextSyncer.service";
+
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
+    private readonly Func<string> hostProvider;
+    private readonly Func<int> portProvider;
+    private readonly string deviceName;
+    private readonly CancellationTokenSource cancellation = new();
+    private UdpClient? udpClient;
+    private Task? listenTask;
+
+    public DiscoveryResponderService(Func<string> hostProvider, Func<int> portProvider, string? deviceName = null)
+    {
+        this.hostProvider = hostProvider;
+        this.portProvider = portProvider;
+        this.deviceName = string.IsNullOrWhiteSpace(deviceName) ? Environment.MachineName : deviceName;
+    }
+
+    public void Start()
+    {
+        if (udpClient is not null)
+        {
+            return;
+        }
+
+        udpClient = new UdpClient(AddressFamily.InterNetwork);
+        udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+        udpClient.EnableBroadcast = true;
+        udpClient.Client.Bind(new IPEndPoint(IPAddress.Any, DiscoveryPort));
+        listenTask = Task.Run(ListenAsync);
+        AppLogger.Info($"Discovery responder listening on UDP {DiscoveryPort}.");
+    }
+
+    public void Dispose()
+    {
+        cancellation.Cancel();
+        udpClient?.Dispose();
+
+        try
+        {
+            listenTask?.Wait(TimeSpan.FromSeconds(1));
+        }
+        catch (AggregateException)
+        {
+        }
+
+        cancellation.Dispose();
+    }
+
+    public string BuildResponseJson()
+    {
+        return JsonSerializer.Serialize(
+            new DiscoveryResponse(ServiceResponseType, 1, deviceName, hostProvider(), portProvider()),
+            JsonOptions);
+    }
+
+    private async Task ListenAsync()
+    {
+        var token = cancellation.Token;
+        while (!token.IsCancellationRequested && udpClient is not null)
+        {
+            try
+            {
+                var result = await udpClient.ReceiveAsync(token);
+                if (!IsDiscoveryRequest(result.Buffer))
+                {
+                    continue;
+                }
+
+                var responseBytes = Encoding.UTF8.GetBytes(BuildResponseJson());
+                await udpClient.SendAsync(responseBytes, result.RemoteEndPoint, token);
+                AppLogger.Info($"Answered discovery request from {result.RemoteEndPoint}.");
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+            catch (ObjectDisposedException)
+            {
+                break;
+            }
+            catch (Exception exception)
+            {
+                AppLogger.Error("Discovery responder failed to process a packet.", exception);
+            }
+        }
+    }
+
+    private static bool IsDiscoveryRequest(byte[] bytes)
+    {
+        try
+        {
+            var request = JsonSerializer.Deserialize<DiscoveryRequest>(bytes, JsonOptions);
+            return request?.Type == DiscoveryRequestType && request.Version == 1;
+        }
+        catch (JsonException)
+        {
+            return false;
+        }
+    }
+
+    private sealed record DiscoveryRequest(string Type, int Version);
+
+    private sealed record DiscoveryResponse(string Type, int Version, string Name, string Host, int Port);
+}

WirelessTextSyncer.Windows/Tray/TrayApplicationContext.cs

@@ -6,7 +6,10 @@ public sealed class TrayApplicationContext : ApplicationContext
 {
     private readonly KeyboardInjectionService keyboard;
     private readonly WebSocketServerService server;
+    private readonly DiscoveryResponderService discovery;
     private readonly NotifyIcon notifyIcon;
+    private readonly Icon connectedIcon;
+    private readonly Icon waitIcon;
     private ToolStripMenuItem? clipboardPasteMenuItem;
     private ToolStripMenuItem? sendInputTypingMenuItem;
 
@@ -17,11 +20,14 @@ public sealed class TrayApplicationContext : ApplicationContext
         var handler = new SyncMessageHandler(keyboard);
 
         server = new WebSocketServerService(handler);
-        server.StatusChanged += (_, _) => UpdateTrayText();
+        server.StatusChanged += (_, _) => UpdateTrayStatus();
+        discovery = new DiscoveryResponderService(() => server.LocalIpAddress, () => server.Port);
+        connectedIcon = TrayIconFactory.CreateConnectedIcon();
+        waitIcon = TrayIconFactory.CreateWaitIcon();
 
         notifyIcon = new NotifyIcon
         {
-            Icon = SystemIcons.Application,
+            Icon = waitIcon,
             Text = "WirelessTextSyncer starting...",
             Visible = true,
             ContextMenuStrip = BuildMenu()
@@ -31,7 +37,8 @@ public sealed class TrayApplicationContext : ApplicationContext
         try
         {
             server.Start(8181);
-            UpdateTrayText();
+            discovery.Start();
+            UpdateTrayStatus();
         }
         catch (Exception ex)
         {
@@ -47,6 +54,9 @@ public sealed class TrayApplicationContext : ApplicationContext
         if (disposing)
         {
             notifyIcon.Dispose();
+            connectedIcon.Dispose();
+            waitIcon.Dispose();
+            discovery.Dispose();
             server.Dispose();
         }
 
@@ -127,10 +137,12 @@ public sealed class TrayApplicationContext : ApplicationContext
         notifyIcon.ShowBalloonTip(1500);
     }
 
-    private void UpdateTrayText()
+    private void UpdateTrayStatus()
     {
-        var status = server.HasClient ? "connected" : "waiting";
+        var connected = server.HasClient;
+        var status = connected ? "connected" : "waiting";
         var text = $"WirelessTextSyncer {server.LocalIpAddress}:{server.Port} ({status})";
+        notifyIcon.Icon = connected ? connectedIcon : waitIcon;
         notifyIcon.Text = text.Length > 63 ? text[..63] : text;
     }
 }

WirelessTextSyncer.Windows/Tray/TrayIconFactory.cs

@@ -0,0 +1,50 @@
+using System.Drawing.Imaging;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace WirelessTextSyncer.Windows.Tray;
+
+internal static class TrayIconFactory
+{
+    private const string ConnectedResourceName = "WirelessTextSyncer.TrayConnected.png";
+    private const string WaitResourceName = "WirelessTextSyncer.TrayWait.png";
+
+    public static Icon CreateConnectedIcon()
+    {
+        return CreateIconFromResource(ConnectedResourceName);
+    }
+
+    public static Icon CreateWaitIcon()
+    {
+        return CreateIconFromResource(WaitResourceName);
+    }
+
+    private static Icon CreateIconFromResource(string resourceName)
+    {
+        var assembly = Assembly.GetExecutingAssembly();
+        using var stream = assembly.GetManifestResourceStream(resourceName)
+            ?? throw new InvalidOperationException($"Tray icon resource not found: {resourceName}");
+        using var source = new Bitmap(stream);
+        using var bitmap = new Bitmap(source.Width, source.Height, PixelFormat.Format32bppArgb);
+        using (var graphics = Graphics.FromImage(bitmap))
+        {
+            graphics.Clear(Color.Transparent);
+            graphics.DrawImage(source, 0, 0, source.Width, source.Height);
+        }
+
+        var handle = bitmap.GetHicon();
+        try
+        {
+            using var icon = Icon.FromHandle(handle);
+            return (Icon)icon.Clone();
+        }
+        finally
+        {
+            DestroyIcon(handle);
+        }
+    }
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool DestroyIcon(IntPtr handle);
+}

WirelessTextSyncer.Windows/WirelessTextSyncer.Windows.csproj

@@ -6,6 +6,7 @@
     <Nullable>enable</Nullable>
     <UseWindowsForms>true</UseWindowsForms>
     <ImplicitUsings>enable</ImplicitUsings>
+    <ApplicationIcon>Resources\Icons\app.ico</ApplicationIcon>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,4 +14,9 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.8" />
   </ItemGroup>
 
-</Project>
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\Icons\tray-connected.png" LogicalName="WirelessTextSyncer.TrayConnected.png" />
+    <EmbeddedResource Include="Resources\Icons\tray-wait.png" LogicalName="WirelessTextSyncer.TrayWait.png" />
+  </ItemGroup>
+
+</Project>