fix lifecycle cleanup issues

open_wearable/lib/models/sensor_streams.dart

@@ -13,10 +13,13 @@ class SensorStreams {
   static final Map<Sensor, Stream<SensorValue>> _sharedStreams = {};
 
   static Stream<SensorValue> shared(Sensor sensor) {
-    return _sharedStreams.putIfAbsent(
-      sensor,
-      () => sensor.sensorStream.asBroadcastStream(),
-    );
+    return _sharedStreams.putIfAbsent(sensor, () {
+      return sensor.sensorStream.asBroadcastStream(
+        onCancel: (_) {
+          _sharedStreams.remove(sensor);
+        },
+      );
+    });
   }
 
   static void clearForSensor(Sensor sensor) {

open_wearable/lib/view_models/sensor_recorder_provider.dart

@@ -171,4 +171,13 @@ class SensorRecorderProvider with ChangeNotifier {
       );
     }
   }
+
+  @override
+  void dispose() {
+    for (final wearable in _recorders.keys.toList()) {
+      _disposeWearable(wearable);
+    }
+    _recorders.clear();
+    super.dispose();
+  }
 }

open_wearable/lib/view_models/wearables_provider.dart

@@ -107,6 +107,7 @@ class WearablesProvider with ChangeNotifier {
   final Map<Wearable, SensorConfigurationProvider>
       _sensorConfigurationProviders = {};
   final Set<String> _splitStereoPairKeys = {};
+  bool _disposed = false;
 
   List<Wearable> get wearables => _wearables;
   Map<Wearable, SensorConfigurationProvider> get sensorConfigurationProviders =>
@@ -161,9 +162,19 @@ class WearablesProvider with ChangeNotifier {
       _wearables.any((w) => w.deviceId == wearable.deviceId);
 
   void _emitWearableEvent(WearableEvent event) {
+    if (_disposed || _wearableEventController.isClosed) {
+      return;
+    }
     _wearableEventController.add(event);
   }
 
+  void _emitUnsupportedFirmwareEvent(UnsupportedFirmwareEvent event) {
+    if (_disposed || _unsupportedFirmwareEventsController.isClosed) {
+      return;
+    }
+    _unsupportedFirmwareEventsController.add(event);
+  }
+
   void _emitWearableError({
     required Wearable wearable,
     required String errorMessage,
@@ -180,6 +191,9 @@ class WearablesProvider with ChangeNotifier {
 
   void _scheduleMicrotask(FutureOr<void> Function() work) {
     Future.microtask(() async {
+      if (_disposed) {
+        return;
+      }
       try {
         await work();
       } catch (e, st) {
@@ -374,16 +388,14 @@ class WearablesProvider with ChangeNotifier {
           // All good, nothing to do.
           break;
         case FirmwareSupportStatus.tooNew:
-          _unsupportedFirmwareEventsController
-              .add(FirmwareTooNewEvent(wearable));
+          _emitUnsupportedFirmwareEvent(FirmwareTooNewEvent(wearable));
           break;
         case FirmwareSupportStatus.unsupported:
-          _unsupportedFirmwareEventsController
-              .add(FirmwareUnsupportedEvent(wearable));
+          _emitUnsupportedFirmwareEvent(FirmwareUnsupportedEvent(wearable));
           break;
         case FirmwareSupportStatus.tooOld:
-          _unsupportedFirmwareEventsController
-              .add(FirmwareTooOldEvent(wearable));
+          _emitUnsupportedFirmwareEvent(FirmwareTooOldEvent(wearable));
+          break;
         case FirmwareSupportStatus.unknown:
           logger.w('Firmware support unknown for ${wearable.name}');
           break;
@@ -419,7 +431,7 @@ class WearablesProvider with ChangeNotifier {
         logger.i(
           'Newer firmware available for ${(dev as Wearable).name}: $currentVersion -> $latestVersion',
         );
-        _wearableEventController.add(
+        _emitWearableEvent(
           NewFirmwareAvailableEvent(
             wearable: dev as Wearable,
             currentVersion: currentVersion,
@@ -483,9 +495,11 @@ class WearablesProvider with ChangeNotifier {
       ),
     );
     _wearables.remove(wearable);
-    _sensorConfigurationProviders.remove(wearable);
+    _sensorConfigurationProviders.remove(wearable)?.dispose();
     _capabilitySubscriptions.remove(wearable)?.cancel();
-    notifyListeners();
+    if (!_disposed) {
+      notifyListeners();
+    }
   }
 
   SensorConfigurationProvider getSensorConfigurationProvider(
@@ -514,8 +528,31 @@ class WearablesProvider with ChangeNotifier {
         ),
       );
     }
+    if (_disposed) {
+      return;
+    }
     if (addedCapabilites.isNotEmpty) {
       notifyListeners();
     }
   }
+
+  @override
+  void dispose() {
+    _disposed = true;
+    for (final sub in _capabilitySubscriptions.values) {
+      unawaited(sub.cancel());
+    }
+    _capabilitySubscriptions.clear();
+
+    for (final provider in _sensorConfigurationProviders.values) {
+      provider.dispose();
+    }
+    _sensorConfigurationProviders.clear();
+    _wearables.clear();
+    _splitStereoPairKeys.clear();
+
+    unawaited(_unsupportedFirmwareEventsController.close());
+    unawaited(_wearableEventController.close());
+    super.dispose();
+  }
 }