feat: Update DiscoveryManager to handle DiscoveredDevice for lost events

- Changed the type of lost device events from String to DiscoveredDevice in DiscoveryManager and related classes.
- Added disposal logic to prevent memory leaks in DefaultDiscoveryManager.
- Updated tests to reflect changes in device lost event handling and ensure proper disposal of DiscoveryManager.
- Enhanced kernel to handle known device discovery updates and lost device events more effectively.
- Introduced new device candidates store to manage newly discovered devices and prevent duplicates.
- Implemented provisioning wizard view model to streamline device provisioning process.

Author: oldrev

client/integration_test/app_test.dart

@@ -45,6 +45,7 @@ Future<Widget> _buildTestApp({IDeviceModuleRegistry? registry}) async {
 // Tests
 // ---------------------------------------------------------------------------
 
+/*
 /// Repeatedly pumps the tester until [finder] is found or the [timeout]
 /// expires.  This is more reliable than `pumpAndSettle` when the UI shows an
 /// indefinite animation (e.g. a loading spinner) that would otherwise keep
@@ -59,6 +60,7 @@ Future<void> _waitFor(WidgetTester tester, Finder finder, {Duration timeout = co
   await tester.pump();
   expect(tester.any(finder), true, reason: 'Expected $finder to appear within $timeout');
 }
+*/
 
 void main() {
   IntegrationTestWidgetsFlutterBinding.ensureInitialized();

client/lib/app/app.dart

@@ -27,6 +27,7 @@ import '../core/services/devices/device_manager.dart';
 import '../core/services/group_manager.dart';
 import '../core/services/chore_manager.dart';
 import '../core/services/scene_manager.dart';
+import '../features/devices/providers/new_device_candidates_store.dart';
 import 'package:borneo_app/core/services/devices/device_module_registry.dart';
 import 'package:borneo_app/core/config/language_config.dart';
 
@@ -223,6 +224,11 @@ class _BorneoAppState extends State<BorneoApp> {
                     dispose: (context, dm) => dm.dispose(),
                   ),
 
+                  ChangeNotifierProvider<NewDeviceCandidatesStore>(
+                    create: (context) => NewDeviceCandidatesStore(context.read<IDeviceManager>()),
+                    lazy: false,
+                  ),
+
                   // ChoreManager
                   Provider<IChoreManager>(
                     create: (context) => ChoreManagerImpl(

client/lib/core/services/devices/device_manager.dart

@@ -43,6 +43,7 @@ abstract class IDeviceManager implements IDisposable {
   Future<void> unbind(String deviceID);
   Future<void> delete(String id, {Transaction? tx, CancellationToken? cancelToken});
   Future<void> update(String id, {Transaction? tx, String? name, String? groupID});
+  Future<void> updateAddress(String id, Uri address, {CancellationToken? cancelToken});
   Future<void> moveToGroup(String id, String newGroupID);
   Future<bool> isNewDevice(SupportedDeviceDescriptor matched, {Transaction? tx});
   Future<DeviceEntity?> singleOrDefaultByFingerprint(String fingerprint, {Transaction? tx});

client/lib/core/services/devices/device_manager_impl.dart

@@ -37,6 +37,7 @@ final class DeviceManagerImpl extends IDeviceManager {
 
   // event subscriptions
   late final StreamSubscription<UnboundDeviceDiscoveredEvent> _unboundDeviceDiscoveredEventSub;
+  late final StreamSubscription<KnownDeviceDiscoveryUpdatedEvent> _knownDeviceDiscoveryUpdatedEventSub;
   late final StreamSubscription<CurrentSceneChangedEvent> _currentSceneChangedEventSub;
 
   // WotThing management
@@ -58,6 +59,9 @@ final class DeviceManagerImpl extends IDeviceManager {
     _unboundDeviceDiscoveredEventSub = allDeviceEvents.on<UnboundDeviceDiscoveredEvent>().listen(
       _onUnboundDeviceDiscovered,
     );
+    _knownDeviceDiscoveryUpdatedEventSub = allDeviceEvents.on<KnownDeviceDiscoveryUpdatedEvent>().listen(
+      _onKnownDeviceDiscoveryUpdated,
+    );
 
     // Listen for scene changes to manage WotThing lifecycle
     _currentSceneChangedEventSub = _globalBus.on<CurrentSceneChangedEvent>().listen(_onCurrentSceneChanged);
@@ -105,6 +109,7 @@ final class DeviceManagerImpl extends IDeviceManager {
   void dispose() {
     if (!_isDisposed) {
       _unboundDeviceDiscoveredEventSub.cancel();
+      _knownDeviceDiscoveryUpdatedEventSub.cancel();
       _currentSceneChangedEventSub.cancel();
 
       _disposeAllWotThings();
@@ -191,13 +196,29 @@ final class DeviceManagerImpl extends IDeviceManager {
   @override
   Future<void> update(String id, {Transaction? tx, String? name, String? groupID}) async {
     if (tx == null) {
-      return await _db.transaction((tx) => _update(id, tx: tx, name: name, groupID: groupID));
+      await _db.transaction((tx) async {
+        await _update(id, tx: tx, name: name, groupID: groupID);
+      });
     } else {
       await _update(id, tx: tx, name: name, groupID: groupID);
     }
   }
 
-  Future<void> _update(String id, {required Transaction tx, String? name, String? groupID}) async {
+  @override
+  Future<void> updateAddress(String id, Uri address, {CancellationToken? cancelToken}) async {
+    final updatedEntity = await _db
+        .transaction((tx) => _update(id, tx: tx, address: address))
+        .asCancellable(cancelToken);
+    await _refreshKernelRegistration(updatedEntity, cancelToken: cancelToken);
+  }
+
+  Future<DeviceEntity> _update(
+    String id, {
+    required Transaction tx,
+    String? name,
+    String? groupID,
+    Uri? address,
+  }) async {
     final store = stringMapStoreFactory.store(StoreNames.devices);
     final originalRecord = await store.record(id).get(tx);
     if (originalRecord == null) {
@@ -212,10 +233,14 @@ final class DeviceManagerImpl extends IDeviceManager {
     if (groupID != null) {
       fieldsToUpdate[DeviceEntity.kGroupIDFieldName] = groupID;
     }
+    if (address != null) {
+      fieldsToUpdate[DeviceEntity.kAddressFieldName] = address.toString();
+    }
 
     final updatedRecord = await store.record(id).update(tx, fieldsToUpdate);
     final updatedEntity = DeviceEntity.fromMap(id, updatedRecord!);
     allDeviceEvents.fire(DeviceEntityUpdatedEvent(oldEntity, updatedEntity));
+    return updatedEntity;
   }
 
   Future<bool> _groupExists(Transaction tx, String groupID) async {
@@ -226,15 +251,15 @@ final class DeviceManagerImpl extends IDeviceManager {
 
   @override
   Future<void> moveToGroup(String id, String newGroupID) async {
-    return await _db.transaction((tx) async {
+    await _db.transaction((tx) async {
       // Allow empty string for ungrouped devices
       if (newGroupID.isNotEmpty) {
         final exists = await _groupExists(tx, newGroupID);
         if (!exists) {
           throw KeyNotFoundException(message: 'Cannot find group with ID `$newGroupID`');
         }
       }
-      return await _update(id, tx: tx, groupID: newGroupID);
+      await _update(id, tx: tx, groupID: newGroupID);
     });
   }
 
@@ -367,22 +392,47 @@ final class DeviceManagerImpl extends IDeviceManager {
 
     return await _db.transaction((tx) async {
       final existed = await singleOrDefaultByFingerprint(event.matched.fingerprint, tx: tx);
-      if (existed != null) {
-        final updates = <String, dynamic>{};
-        if (event.matched.address != existed.address) {
-          updates[DeviceEntity.kAddressFieldName] = event.matched.address.toString();
-        }
-        if (updates.isNotEmpty) {
-          final store = stringMapStoreFactory.store(StoreNames.devices);
-          final record = store.record(existed.id);
-          await record.update(tx, updates);
-        }
-      } else {
+      if (existed == null) {
         allDeviceEvents.fire(NewDeviceFoundEvent(event.matched));
       }
     });
   }
 
+  Future<void> _onKnownDeviceDiscoveryUpdated(KnownDeviceDiscoveryUpdatedEvent event) async {
+    logger?.i('Known device discovery updated: ${event.device.id} -> ${event.matched.address}');
+    assert(isInitialized);
+
+    if (event.device.address == event.matched.address) {
+      return;
+    }
+
+    await updateAddress(event.device.id, event.matched.address);
+  }
+
+  Future<void> _refreshKernelRegistration(DeviceEntity updatedEntity, {CancellationToken? cancelToken}) async {
+    final wasBound = _kernel.boundDevices.any((bound) => bound.device.id == updatedEntity.id);
+
+    _kernel.enterHeartbeatBatch();
+    try {
+      await _deviceOperLock
+          .synchronized(() async {
+            if (wasBound) {
+              await _kernel.unbind(updatedEntity.id, cancelToken: cancelToken);
+            }
+
+            _kernel.unregisterDevice(updatedEntity.id);
+            _kernel.registerDevice(BoundDeviceDescriptor(device: updatedEntity, driverID: updatedEntity.driverID));
+
+            if (wasBound) {
+              await _kernel.tryBind(updatedEntity, updatedEntity.driverID, cancelToken: cancelToken);
+            }
+          })
+          .asCancellable(cancelToken);
+    } finally {
+      _kernel.exitHeartbeatBatch();
+    }
+  }
+
   @override
   WotThing getWotThing(String deviceID) {
     // Only return WotThings for devices that are already loaded (current scene)

client/lib/core/services/devices/mdns.dart

@@ -40,33 +40,39 @@ final class NsdMdnsDiscovery implements IMdnsDiscovery {
     switch (event) {
       case BonsoirDiscoveryServiceFoundEvent():
         {
-          event.service.resolve(
-            _discovery.serviceResolver,
-          ); // Should be called when the user wants to connect to this service.
+          event.service.resolve(_discovery.serviceResolver);
         }
         break;
       case BonsoirDiscoveryServiceResolvedEvent():
         {
-          String host = event.service.host ?? 'UNKNOWN';
-          final discovered = MdnsDiscoveredDevice(
-            host: host,
-            port: event.service.port,
-            serviceType: event.service.type,
-            name: event.service.name,
-            txt: event.service.attributes,
-          );
-          _eventBus.fire(FoundDeviceEvent(discovered));
+          _eventBus.fire(FoundDeviceEvent(_toDiscoveredDevice(event.service)));
         }
         break;
       case BonsoirDiscoveryServiceUpdatedEvent():
+        {
+          _eventBus.fire(FoundDeviceEvent(_toDiscoveredDevice(event.service)));
+        }
         break;
       case BonsoirDiscoveryServiceLostEvent():
+        {
+          _eventBus.fire(LostDeviceEvent(_toDiscoveredDevice(event.service)));
+        }
         break;
       default:
         break;
     }
   }
 
+  MdnsDiscoveredDevice _toDiscoveredDevice(BonsoirService service) {
+    return MdnsDiscoveredDevice(
+      host: service.host ?? 'UNKNOWN',
+      port: service.port,
+      serviceType: service.type,
+      name: service.name,
+      txt: service.attributes,
+    );
+  }
+
   @override
   String get serviceType => _serviceType;
 

client/lib/devices/borneo/lyfi/views/settings_screen.dart

@@ -356,6 +356,7 @@ class SettingsScreen extends StatelessWidget {
     }
   }
 
+  /*
   Future<void> _showDeleteDialog(BuildContext context, SettingsViewModel vm) async {
     final confirmed = await AsyncConfirmationSheet.show(
       context,
@@ -370,6 +371,7 @@ class SettingsScreen extends StatelessWidget {
       }
     });
   }
+  */
 
   void _showManualFanPowerDialog(BuildContext context, SettingsViewModel vm, int currentValue) {
     double tempValue = currentValue.toDouble();

client/lib/features/devices/providers/new_device_candidates_store.dart

@@ -0,0 +1,73 @@
+import 'dart:async';
+import 'dart:collection';
+
+import 'package:borneo_app/core/services/devices/device_manager.dart';
+import 'package:borneo_app/features/devices/models/events.dart';
+import 'package:borneo_kernel_abstractions/models/supported_device_descriptor.dart';
+import 'package:flutter/foundation.dart';
+
+class NewDeviceCandidatesStore extends ChangeNotifier {
+  final IDeviceManager _deviceManager;
+  final Map<String, SupportedDeviceDescriptor> _candidatesByFingerprint = {};
+  late final StreamSubscription<NewDeviceFoundEvent> _newDeviceFoundSub;
+  late final StreamSubscription<NewDeviceEntityAddedEvent> _newDeviceAddedSub;
+  bool _disposed = false;
+
+  NewDeviceCandidatesStore(this._deviceManager) {
+    _newDeviceFoundSub = _deviceManager.allDeviceEvents.on<NewDeviceFoundEvent>().listen(_onNewDeviceFound);
+    _newDeviceAddedSub = _deviceManager.allDeviceEvents.on<NewDeviceEntityAddedEvent>().listen(_onNewDeviceAdded);
+  }
+
+  UnmodifiableListView<SupportedDeviceDescriptor> get candidates {
+    return UnmodifiableListView(_candidatesByFingerprint.values);
+  }
+
+  int get count => _candidatesByFingerprint.length;
+
+  SupportedDeviceDescriptor? byFingerprint(String fingerprint) {
+    return _candidatesByFingerprint[fingerprint];
+  }
+
+  void _onNewDeviceFound(NewDeviceFoundEvent event) {
+    final previous = _candidatesByFingerprint[event.device.fingerprint];
+    if (_isSameCandidate(previous, event.device)) {
+      return;
+    }
+
+    _candidatesByFingerprint[event.device.fingerprint] = event.device;
+    _notifyIfActive();
+  }
+
+  void _onNewDeviceAdded(NewDeviceEntityAddedEvent event) {
+    if (_candidatesByFingerprint.remove(event.device.fingerprint) != null) {
+      _notifyIfActive();
+    }
+  }
+
+  bool _isSameCandidate(SupportedDeviceDescriptor? left, SupportedDeviceDescriptor right) {
+    if (left == null) {
+      return false;
+    }
+
+    return left.fingerprint == right.fingerprint &&
+        left.address == right.address &&
+        left.name == right.name &&
+        left.driverDescriptor.id == right.driverDescriptor.id;
+  }
+
+  void _notifyIfActive() {
+    if (!_disposed) {
+      notifyListeners();
+    }
+  }
+
+  @override
+  void dispose() {
+    if (!_disposed) {
+      _disposed = true;
+      _newDeviceFoundSub.cancel();
+      _newDeviceAddedSub.cancel();
+    }
+    super.dispose();
+  }
+}