fix: show Windows PC names on iOS (#100)

* fix: show Windows PC names on iOS

* fix: distinguish iOS Windows advertisements

---------

Co-authored-by: Owen McGirr <owenmcgirr@Owens-Mac-Studio-2.local>

Author: enaboapps

src/connection/integration.test.ts

@@ -33,6 +33,7 @@ class LoopbackTransport implements BleTransport {
   requestIds: { id: string; type: string; authenticated: boolean }[] = [];
   connectCount = 0;
   connectFailures = 0;
+  resolvedDesktop = desktop;
   readinessGate: Promise<void> | null = null;
   responseGates = new Map<string, Promise<void>>();
   responseGateQueues = new Map<string, Promise<void>[]>();
@@ -44,7 +45,7 @@ class LoopbackTransport implements BleTransport {
   resolveAndConnect = async () => {
     this.connectCount += 1;
     if (this.connectFailures > 0) { this.connectFailures -= 1; throw new Error('connect failed'); }
-    return desktop;
+    return this.resolvedDesktop;
   };
   connect = async () => undefined;
   disconnect = async () => undefined;
@@ -109,6 +110,20 @@ describe('pairing and authenticated connection integration', () => {
     expect(transport.requestPayloads.find(({ type }) => type === 'connection.ping')?.payload).toEqual({ deviceName: 'OPD2403' });
   });
 
+  it('refreshes a saved Windows name after successful authentication', async () => {
+    const transport = new LoopbackTransport();
+    transport.resolvedDesktop = { ...desktop, displayName: 'Owen’s Windows PC' };
+    const storage = new MemoryStorage();
+    storage.saved = [{ ...desktop, displayName: 'Switchify PC', lastConnectedAt: 1 }];
+    storage.tokens.set(desktop.desktopId, 'fixture-secret');
+    const manager = new ConnectionManager(transport, storage, new DiagnosticLog(), async () => true);
+
+    await manager.connectSaved(storage.saved[0]!);
+
+    expect(storage.saved[0]).toMatchObject({ desktopId: desktop.desktopId, displayName: 'Owen’s Windows PC' });
+    expect(manager.snapshot()).toMatchObject({ kind: 'connected', desktop: { displayName: 'Owen’s Windows PC' } });
+  });
+
   it('updates a connected PC and defers when offline', async () => {
     let remoteName = 'OPD2403';
     const transport = new LoopbackTransport();

src/transport/ReactNativeBleTransport.test.ts

@@ -6,7 +6,7 @@ const descriptor = (value: string): Descriptor => ({ value } as Descriptor);
 
 function device(overrides: Partial<Device> = {}): Device {
   const base: Record<string, unknown> = {
-    id: 'ble-1', name: null, mtu: 185, rssi: -42,
+    id: 'ble-1', name: null, localName: null, mtu: 185, rssi: -42,
     isConnected: jest.fn(async () => true), cancelConnection: jest.fn(async () => null as unknown as Device),
     requestConnectionPriority: jest.fn(async () => base),
     requestMTU: jest.fn(async () => ({ ...base, mtu: 517 })),
@@ -410,7 +410,7 @@ describe('ReactNativeBleTransport', () => {
 
   it('publishes the actual Windows Bluetooth device name', async () => {
     let scanCallback!: (error: Error | null, value: Device | null) => void;
-    const advertised = device({ name: 'Oliver Laptop' });
+    const advertised = device({ name: 'Oliver Laptop', localName: 'Switchify PC' });
     const native = manager({ startDeviceScan: jest.fn((_uuids, _options, callback) => { scanCallback = callback; }) });
     const transport = new ReactNativeBleTransport(native, 'android');
     const found = jest.fn();
@@ -422,6 +422,45 @@ describe('ReactNativeBleTransport', () => {
     stop();
   });
 
+  it('publishes the advertised Windows local name on iOS', async () => {
+    let scanCallback!: (error: Error | null, value: Device | null) => void;
+    const advertised = device({ name: 'Switchify PC', localName: 'Owen’s Windows PC' });
+    const native = manager({ startDeviceScan: jest.fn((_uuids, _options, callback) => { scanCallback = callback; }) });
+    const transport = new ReactNativeBleTransport(native, 'ios');
+    const found = jest.fn();
+    const stop = transport.scan(found, jest.fn());
+
+    scanCallback(null, advertised);
+    await waitFor(() => found.mock.calls.length === 1);
+
+    expect(found).toHaveBeenCalledWith(expect.objectContaining({ displayName: 'Owen’s Windows PC', platform: 'windows' }));
+    stop();
+  });
+
+  it('discovers multiple Windows PCs with a generic iOS device name', async () => {
+    let scanCallback!: (error: Error | null, value: Device | null) => void;
+    const makeWindowsPc = (id: string, desktopId: string, localName: string) => device({
+      id,
+      name: 'Switchify PC',
+      localName,
+      readCharacteristicForService: jest.fn(async () => ({ value: fromByteArray(new TextEncoder().encode(JSON.stringify({ protocolVersion: 1, desktopId, displayName: 'Switchify PC', platform: 'windows' }))) } as Characteristic)),
+    });
+    const first = makeWindowsPc('windows-1', 'pc-1', 'Office PC');
+    const second = makeWindowsPc('windows-2', 'pc-2', 'Living Room PC');
+    const native = manager({ startDeviceScan: jest.fn((_uuids, _options, callback) => { scanCallback = callback; }) });
+    const transport = new ReactNativeBleTransport(native, 'ios');
+    const found = jest.fn();
+    const stop = transport.scan(found, jest.fn());
+
+    scanCallback(null, first);
+    await waitFor(() => found.mock.calls.some(([desktop]) => desktop.desktopId === 'pc-1'));
+    scanCallback(null, second);
+    await waitFor(() => found.mock.calls.some(([desktop]) => desktop.desktopId === 'pc-2'));
+
+    expect(found.mock.calls.map(([desktop]) => desktop.displayName)).toEqual(['Office PC', 'Living Room PC']);
+    stop();
+  });
+
   it('hands a matching discovery connection directly to the authenticated session', async () => {
     let scanCallback!: (error: Error | null, value: Device | null) => void;
     const configured = device({ isConnected: jest.fn(async () => true), mtu: 517 });

src/transport/ReactNativeBleTransport.ts

@@ -5,7 +5,7 @@ import { toByteArray } from 'base64-js';
 import { BLE_DESCRIPTORS, BLE_UUIDS } from '@/domain/protocol/constants';
 import { parseStatus } from '@/domain/protocol/responses';
 import type { BleAvailability, BleTransport, DiscoveredDesktop, Unsubscribe } from './BleTransport';
-import { desktopDisplayName } from './desktopDisplayName';
+import { bluetoothDeviceDisplayName, desktopDisplayName } from './desktopDisplayName';
 
 export class ReactNativeBleTransport implements BleTransport {
   #manager: BleManager | null;
@@ -310,7 +310,7 @@ export class ReactNativeBleTransport implements BleTransport {
       const status = parseStatus(raw);
       const desktop = status ? {
         ...status,
-        displayName: desktopDisplayName(status, device.name),
+        displayName: desktopDisplayName(status, { name: device.name, localName: device.localName }, this.platform),
         peripheralId: device.id,
         rssi: device.rssi ?? null,
       } : null;
@@ -371,7 +371,8 @@ export class ReactNativeBleTransport implements BleTransport {
   }
 
   #scanKey(device: Device): string {
-    return device.name ? `name:${device.name}` : `id:${device.id}`;
+    const name = bluetoothDeviceDisplayName({ name: device.name, localName: device.localName }, this.platform);
+    return name ? `name:${name}` : `id:${device.id}`;
   }
 
   #bounded<T>(operation: Promise<T>, timeoutMs = this.nativeTimeoutMs): Promise<T> {

src/transport/desktopDisplayName.test.ts

@@ -4,24 +4,60 @@ describe('desktopDisplayName', () => {
   it('prefers the Bluetooth device name for Windows', () => {
     expect(desktopDisplayName(
       { desktopId: 'pc-1', displayName: 'Switchify PC', platform: 'windows' },
-      '  Oliver Laptop  ',
+      { name: '  Oliver Laptop  ', localName: 'Switchify PC' },
+      'android',
     )).toBe('Oliver Laptop');
   });
 
+  it('prefers the advertised local name for Windows on iOS', () => {
+    expect(desktopDisplayName(
+      { desktopId: 'pc-1', displayName: 'Switchify PC', platform: 'windows' },
+      { name: 'Cached Windows Name', localName: '  Owen’s Windows PC  ' },
+      'ios',
+    )).toBe('Owen’s Windows PC');
+  });
+
+  it('preserves Android device-name precedence', () => {
+    expect(desktopDisplayName(
+      { desktopId: 'pc-1', displayName: 'Status Name', platform: 'windows' },
+      { name: 'Android Device Name', localName: 'Advertisement Name' },
+      'android',
+    )).toBe('Android Device Name');
+  });
+
+  it('uses the advertised local name as an Android fallback', () => {
+    expect(desktopDisplayName(
+      { desktopId: 'pc-1', displayName: 'Switchify PC', platform: 'windows' },
+      { name: null, localName: 'Windows Local Name' },
+      'android',
+    )).toBe('Windows Local Name');
+  });
+
   it('prefers the status display name for macOS', () => {
     expect(desktopDisplayName(
       { desktopId: 'pc-1', displayName: 'Owen’s Mac Studio', platform: 'macos' },
-      'Mac',
+      { name: 'Mac', localName: 'Switchify PC' },
+      'ios',
     )).toBe('Owen’s Mac Studio');
   });
 
   it.each([
-    [null, 'Office PC'],
-    ['   ', 'Office PC'],
-  ])('falls back from a missing Windows Bluetooth name', (bluetoothName, expected) => {
+    [{ name: null, localName: null }, 'Office PC'],
+    [{ name: '   ', localName: '   ' }, 'Office PC'],
+    [{ name: 'Switchify PC', localName: 'SWITCHIFY PC' }, 'Office PC'],
+  ])('falls back from missing or generic Windows Bluetooth names', (bluetooth, expected) => {
     expect(desktopDisplayName(
       { desktopId: 'pc-1', displayName: 'Office PC', platform: 'windows' },
-      bluetoothName,
+      bluetooth,
+      'ios',
     )).toBe(expected);
   });
+
+  it('uses a Unicode local name when the iOS device name is unavailable', () => {
+    expect(desktopDisplayName(
+      { desktopId: 'pc-1', displayName: 'Switchify PC', platform: 'windows' },
+      { name: null, localName: '  Büro-PC 日本語  ' },
+      'ios',
+    )).toBe('Büro-PC 日本語');
+  });
 });

src/transport/desktopDisplayName.ts

@@ -2,13 +2,36 @@ import type { PcStatus } from '@/domain/protocol/types';
 
 const PRODUCT_NAME = 'Switchify PC';
 
-export function desktopDisplayName(status: PcStatus, bluetoothDeviceName: string | null | undefined): string {
+export type BluetoothDeviceNames = {
+  name: string | null | undefined;
+  localName: string | null | undefined;
+};
+
+export function bluetoothDeviceDisplayName(bluetooth: BluetoothDeviceNames, remotePlatform: string): string | null {
+  const deviceName = normalized(bluetooth.name);
+  const localName = normalized(bluetooth.localName);
+  const candidates = remotePlatform === 'ios'
+    ? [localName, deviceName]
+    : [deviceName, localName];
+  return candidates.find((candidate) => candidate !== null && !isGeneric(candidate))
+    ?? candidates.find((candidate) => candidate !== null)
+    ?? null;
+}
+
+export function desktopDisplayName(status: PcStatus, bluetooth: BluetoothDeviceNames, remotePlatform: string): string {
   const statusName = normalized(status.displayName);
   if (status.platform === 'macos') return statusName ?? PRODUCT_NAME;
-  return normalized(bluetoothDeviceName) ?? statusName ?? PRODUCT_NAME;
+  const candidates = [bluetoothDeviceDisplayName(bluetooth, remotePlatform), statusName];
+  return candidates.find((candidate) => candidate !== null && !isGeneric(candidate))
+    ?? candidates.find((candidate) => candidate !== null)
+    ?? PRODUCT_NAME;
 }
 
 function normalized(value: string | null | undefined): string | null {
   const name = value?.trim();
   return name ? name : null;
 }
+
+function isGeneric(value: string): boolean {
+  return value.toLowerCase() === PRODUCT_NAME.toLowerCase();
+}