Replace capability checks with new hasCapability/requireCapability API

Copilot · DennisMoschina · DennisMoschina · commit f465d6bb796f · 2026-01-09T15:55:44.000+01:00
Co-authored-by: DennisMoschina &lt;45356478+DennisMoschina@users.noreply.github.com&gt;
diff --git a/open_wearable/lib/apps/widgets/apps_page.dart b/open_wearable/lib/apps/widgets/apps_page.dart
@@ -32,7 +32,7 @@ List<AppInfo> _apps = [
     widget: SelectEarableView(startApp: (wearable, sensorConfigProvider) {
       return PostureTrackerView(
         EarableAttitudeTracker(
-          wearable as SensorManager,
+          wearable.requireCapability<SensorManager>(),
           sensorConfigProvider,
           wearable.name.endsWith("L"),
         ),
@@ -45,9 +45,9 @@ List<AppInfo> _apps = [
     description: "Track your heart rate and other vitals",
     widget: SelectEarableView(
       startApp: (wearable, _) {
-        if (wearable is SensorManager) {
+        if (wearable.hasCapability<SensorManager>()) {
           //TODO: show alert if no ppg sensor is found
-          Sensor ppgSensor = (wearable as SensorManager).sensors.firstWhere(
+          Sensor ppgSensor = wearable.requireCapability<SensorManager>().sensors.firstWhere(
             (s) => s.sensorName.toLowerCase() == "photoplethysmography".toLowerCase(),
           );
 
diff --git a/open_wearable/lib/view_models/sensor_recorder_provider.dart b/open_wearable/lib/view_models/sensor_recorder_provider.dart
@@ -74,8 +74,8 @@ class SensorRecorderProvider with ChangeNotifier {
       notifyListeners();
     });
 
-    if (wearable is SensorManager) {
-      for (Sensor sensor in (wearable as SensorManager).sensors) {
+    if (wearable.hasCapability<SensorManager>()) {
+      for (Sensor sensor in wearable.requireCapability<SensorManager>().sensors) {
         if (!_recorders[wearable]!.containsKey(sensor)) {
           _recorders[wearable]![sensor] = Recorder(columns: sensor.axisNames);
         }
diff --git a/open_wearable/lib/view_models/wearables_provider.dart b/open_wearable/lib/view_models/wearables_provider.dart
@@ -194,18 +194,18 @@ class WearablesProvider with ChangeNotifier {
 
     // 2) Slow/async work: run in microtasks so it doesn't block the add
     // Stereo pairing (if applicable)
-    if (wearable is StereoDevice) {
-      _scheduleMicrotask(() => _maybeAutoPairStereoAsync(wearable as StereoDevice));
+    if (wearable.hasCapability<StereoDevice>()) {
+      _scheduleMicrotask(() => _maybeAutoPairStereoAsync(wearable.requireCapability<StereoDevice>()));
     }
 
     // Firmware support check (if applicable)
-    if (wearable is DeviceFirmwareVersion) {
-      _scheduleMicrotask(() => _maybeEmitUnsupportedFirmwareAsync(wearable as DeviceFirmwareVersion));
+    if (wearable.hasCapability<DeviceFirmwareVersion>()) {
+      _scheduleMicrotask(() => _maybeEmitUnsupportedFirmwareAsync(wearable.requireCapability<DeviceFirmwareVersion>()));
     }
 
     // Check for newer firmware (if applicable)
-    if (wearable is DeviceFirmwareVersion) {
-      _scheduleMicrotask(() => _checkForNewerFirmwareAsync(wearable as DeviceFirmwareVersion));
+    if (wearable.hasCapability<DeviceFirmwareVersion>()) {
+      _scheduleMicrotask(() => _checkForNewerFirmwareAsync(wearable.requireCapability<DeviceFirmwareVersion>()));
     }
   }
 
@@ -214,7 +214,7 @@ class WearablesProvider with ChangeNotifier {
   void _ensureSensorConfigProvider(Wearable wearable) {
     if (!_sensorConfigurationProviders.containsKey(wearable)) {
       _sensorConfigurationProviders[wearable] = SensorConfigurationProvider(
-        sensorConfigurationManager: wearable as SensorConfigurationManager,
+        sensorConfigurationManager: wearable.requireCapability<SensorConfigurationManager>(),
       );
     }
   }
diff --git a/open_wearable/lib/widgets/devices/battery_state.dart b/open_wearable/lib/widgets/devices/battery_state.dart
@@ -13,9 +13,9 @@ class BatteryStateView extends StatelessWidget {
     return Row(
       mainAxisSize: MainAxisSize.min,
       children: [
-        if (_device is BatteryLevelStatus)
+        if (_device.hasCapability<BatteryLevelStatus>())
           StreamBuilder(
-            stream: (_device as BatteryLevelStatus).batteryPercentageStream,
+            stream: _device.requireCapability<BatteryLevelStatus>().batteryPercentageStream,
             builder: (context, snapshot) {
               if (snapshot.hasData) {
                 return PlatformText("${snapshot.data}%");
@@ -24,9 +24,9 @@ class BatteryStateView extends StatelessWidget {
               }
             },
           ),
-        if (_device is BatteryLevelStatusService)
+        if (_device.hasCapability<BatteryLevelStatusService>())
           StreamBuilder(
-            stream: (_device as BatteryLevelStatusService).powerStatusStream,
+            stream: _device.requireCapability<BatteryLevelStatusService>().powerStatusStream,
             builder: (context, snapshot) {
               if (snapshot.hasData) {
                 if (!snapshot.data!.batteryPresent) {
@@ -52,9 +52,9 @@ class BatteryStateView extends StatelessWidget {
               }
             },
           )
-        else if (_device is BatteryLevelStatus)
+        else if (_device.hasCapability<BatteryLevelStatus>())
           StreamBuilder(
-            stream: (_device as BatteryLevelStatus).batteryPercentageStream,
+            stream: _device.requireCapability<BatteryLevelStatus>().batteryPercentageStream,
             builder: (context, snapshot) {
               if (snapshot.hasData) {
                 return Icon(getBatteryIcon(snapshot.data!));
diff --git a/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart b/open_wearable/lib/widgets/devices/device_detail/device_detail_page.dart
@@ -36,8 +36,8 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
   }
 
   Future<void> _initSelectedMicrophone() async {
-    if (widget.device is MicrophoneManager) {
-      final mic = await (widget.device as MicrophoneManager).getMicrophone();
+    if (widget.device.hasCapability<MicrophoneManager>()) {
+      final mic = await widget.device.requireCapability<MicrophoneManager>().getMicrophone();
       setState(() {
         selectedMicrophone = mic;
       });
@@ -67,10 +67,10 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
                   mainAxisAlignment: MainAxisAlignment.center,
                   children: [
                     BatteryStateView(device: widget.device),
-                    if (widget.device is StereoDevice)
+                    if (widget.device.hasCapability<StereoDevice>())
                       Padding(
                         padding: const EdgeInsets.only(left: 8.0),
-                        child: StereoPosLabel(device: widget.device as StereoDevice),
+                        child: StereoPosLabel(device: widget.device.requireCapability<StereoDevice>()),
                       ),
                   ],
                 ),
@@ -79,7 +79,7 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
                 Row(
                   mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                   children: [
-                    if (widget.device is SystemDevice && (widget.device as SystemDevice).isConnectedViaSystem)
+                    if (widget.device.hasCapability<SystemDevice>() && widget.device.requireCapability<SystemDevice>().isConnectedViaSystem)
                       PlatformElevatedButton(
                         child: PlatformText("Forget Device"),
                         onPressed: () {
@@ -112,12 +112,12 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
               ],
             ),
             // MARK: Audio Mode
-            if (widget.device is AudioModeManager)
-              AudioModeWidget(device: widget.device as AudioModeManager),
+            if (widget.device.hasCapability<AudioModeManager>())
+              AudioModeWidget(device: widget.device.requireCapability<AudioModeManager>()),
             // MARK: Microphone Control
-            if (widget.device is MicrophoneManager)
+            if (widget.device.hasCapability<MicrophoneManager>())
               MicrophoneSelectionWidget(
-                device: widget.device as MicrophoneManager,
+                device: widget.device.requireCapability<MicrophoneManager>(),
               ),
             // MARK: Device info
             PlatformText("Device Info", style: Theme.of(context).textTheme.titleSmall),
@@ -129,14 +129,14 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
               subtitle: PlatformText(widget.device.deviceId),
             ),
             // MARK: Device Identifier
-            if (widget.device is DeviceIdentifier)
+            if (widget.device.hasCapability<DeviceIdentifier>())
               PlatformListTile(
                 title: PlatformText(
                   "Device Identifier",
                   style: Theme.of(context).textTheme.bodyLarge,
                 ),
                 subtitle: FutureBuilder(
-                  future: (widget.device as DeviceIdentifier)
+                  future: widget.device.requireCapability<DeviceIdentifier>()
                       .readDeviceIdentifier(),
                   builder: (context, snapshot) {
                     if (snapshot.connectionState == ConnectionState.done) {
@@ -155,15 +155,15 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
                 ),
               ),
             // MARK: Device Firmware Version
-            if (widget.device is DeviceFirmwareVersion)
+            if (widget.device.hasCapability<DeviceFirmwareVersion>())
               PlatformListTile(
                 title: PlatformText(
                   "Firmware Version",
                   style: Theme.of(context).textTheme.bodyLarge,
                 ),
                 subtitle: Row(children: [
                   FutureBuilder(
-                    future: (widget.device as DeviceFirmwareVersion)
+                    future: widget.device.requireCapability<DeviceFirmwareVersion>()
                         .readDeviceFirmwareVersion(),
                     builder: (context, snapshot) {
                       if (snapshot.connectionState == ConnectionState.done) {
@@ -181,7 +181,7 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
                     },
                   ),
                   FutureBuilder(
-                    future: (widget.device as DeviceFirmwareVersion)
+                    future: widget.device.requireCapability<DeviceFirmwareVersion>()
                         .checkFirmwareSupport(),
                     builder: (context, snapshot) {
                       if (snapshot.connectionState == ConnectionState.done) {
@@ -222,14 +222,14 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
                 ),
               ),
             // MARK: Device Hardware Version
-            if (widget.device is DeviceHardwareVersion)
+            if (widget.device.hasCapability<DeviceHardwareVersion>())
               PlatformListTile(
                 title: PlatformText(
                   "Hardware Version",
                   style: Theme.of(context).textTheme.bodyLarge,
                 ),
                 subtitle: FutureBuilder(
-                  future: (widget.device as DeviceHardwareVersion)
+                  future: widget.device.requireCapability<DeviceHardwareVersion>()
                       .readDeviceHardwareVersion(),
                   builder: (context, snapshot) {
                     if (snapshot.connectionState == ConnectionState.done) {
@@ -249,17 +249,17 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
               ),
 
             // MARK: Status LED control
-            if (widget.device is StatusLed) ...[
+            if (widget.device.hasCapability<StatusLed>()) ...[
               PlatformText(
                 "Control Status LED",
                 style: Theme.of(context).textTheme.titleSmall,
               ),
               StatusLEDControlWidget(
-                statusLED: widget.device as StatusLed,
-                rgbLed: widget.device as RgbLed,
+                statusLED: widget.device.requireCapability<StatusLed>(),
+                rgbLed: widget.device.requireCapability<RgbLed>(),
               ),
-            ] else if (widget.device is RgbLed &&
-                widget.device is! StatusLed) ...[
+            ] else if (widget.device.hasCapability<RgbLed>() &&
+                !widget.device.hasCapability<StatusLed>()) ...[
               PlatformText(
                 "Control RGB LED",
                 style: Theme.of(context).textTheme.titleSmall,
@@ -269,18 +269,18 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
                   "LED Color",
                   style: Theme.of(context).textTheme.bodyLarge,
                 ),
-                trailing: RgbControlView(rgbLed: widget.device as RgbLed),
+                trailing: RgbControlView(rgbLed: widget.device.requireCapability<RgbLed>()),
               ),
             ],
 
             // MARK: Device Battery State
-            if (widget.device is BatteryEnergyStatusService) ...[
+            if (widget.device.hasCapability<BatteryEnergyStatusService>()) ...[
               PlatformText(
                 "Battery Energy Status",
                 style: Theme.of(context).textTheme.titleSmall,
               ),
               StreamBuilder<BatteryEnergyStatus>(
-                stream: (widget.device as BatteryEnergyStatusService)
+                stream: widget.device.requireCapability<BatteryEnergyStatusService>()
                     .energyStatusStream,
                 builder: (context, snapshot) {
                   if (snapshot.connectionState == ConnectionState.waiting) {
@@ -326,13 +326,13 @@ class _DeviceDetailPageState extends State<DeviceDetailPage> {
             ],
 
             // MARK: Battery Health
-            if (widget.device is BatteryHealthStatusService) ...[
+            if (widget.device.hasCapability<BatteryHealthStatusService>()) ...[
               PlatformText(
                 "Battery Health Status",
                 style: Theme.of(context).textTheme.titleSmall,
               ),
               StreamBuilder<BatteryHealthStatus>(
-                stream: (widget.device as BatteryHealthStatusService)
+                stream: widget.device.requireCapability<BatteryHealthStatusService>()
                     .healthStatusStream,
                 builder: (context, snapshot) {
                   if (snapshot.connectionState == ConnectionState.waiting) {
diff --git a/open_wearable/lib/widgets/devices/devices_page.dart b/open_wearable/lib/widgets/devices/devices_page.dart
@@ -220,20 +220,20 @@ class DeviceRow extends StatelessWidget {
                       ),
                       Row(children: [
                         BatteryStateView(device: _device),
-                        if (_device is StereoDevice)
+                        if (_device.hasCapability<StereoDevice>())
                           Padding(
                             padding: EdgeInsets.only(left: 8.0),
-                            child: StereoPosLabel(device: _device as StereoDevice),
+                            child: StereoPosLabel(device: _device.requireCapability<StereoDevice>()),
                           ),
                       ],
                     ),
                   ],
                 ),
                 Spacer(),
-                if (_device is DeviceIdentifier)
+                if (_device.hasCapability<DeviceIdentifier>())
                     FutureBuilder(
                       future:
-                          (_device as DeviceIdentifier).readDeviceIdentifier(),
+                          _device.requireCapability<DeviceIdentifier>().readDeviceIdentifier(),
                       builder: (context, snapshot) {
                         if (snapshot.connectionState ==
                             ConnectionState.waiting) {
@@ -249,12 +249,12 @@ class DeviceRow extends StatelessWidget {
                     PlatformText(_device.deviceId),
                 ],
               ),
-              if (_device is DeviceFirmwareVersion)
+              if (_device.hasCapability<DeviceFirmwareVersion>())
                 Row(
                   children: [
                     PlatformText("Firmware Version: "),
                     FutureBuilder(
-                      future: (_device as DeviceFirmwareVersion)
+                      future: _device.requireCapability<DeviceFirmwareVersion>()
                           .readDeviceFirmwareVersion(),
                       builder: (context, snapshot) {
                         if (snapshot.connectionState ==
@@ -268,7 +268,7 @@ class DeviceRow extends StatelessWidget {
                       },
                     ),
                     FutureBuilder(
-                      future: (_device as DeviceFirmwareVersion)
+                      future: _device.requireCapability<DeviceFirmwareVersion>()
                           .checkFirmwareSupport(),
                       builder: (context, snapshot) {
                         if (snapshot.connectionState ==
@@ -300,12 +300,12 @@ class DeviceRow extends StatelessWidget {
                     ),
                   ],
                 ),
-              if (_device is DeviceHardwareVersion)
+              if (_device.hasCapability<DeviceHardwareVersion>())
                 Row(
                   children: [
                     PlatformText("Hardware Version: "),
                     FutureBuilder(
-                      future: (_device as DeviceHardwareVersion)
+                      future: _device.requireCapability<DeviceHardwareVersion>()
                           .readDeviceHardwareVersion(),
                       builder: (context, snapshot) {
                         if (snapshot.connectionState ==
diff --git a/open_wearable/lib/widgets/fota/firmware_select/firmware_list.dart b/open_wearable/lib/widgets/fota/firmware_select/firmware_list.dart
@@ -36,9 +36,9 @@ class _FirmwareListState extends State<FirmwareList> {
     final wearable =
         Provider.of<FirmwareUpdateRequestProvider>(context, listen: false)
             .selectedWearable;
-    if (wearable is DeviceFirmwareVersion) {
+    if (wearable != null && wearable.hasCapability<DeviceFirmwareVersion>()) {
       final version =
-          await (wearable as DeviceFirmwareVersion).readDeviceFirmwareVersion();
+          await wearable.requireCapability<DeviceFirmwareVersion>().readDeviceFirmwareVersion();
       setState(() {
         firmwareVersion = version;
       });
diff --git a/open_wearable/lib/widgets/fota/fota_warning_page.dart b/open_wearable/lib/widgets/fota/fota_warning_page.dart
@@ -33,9 +33,9 @@ class _FotaWarningPageState extends State<FotaWarningPage> {
       );
       final device = updateProvider.selectedWearable;
       
-      if (device != null && device is BatteryLevelStatus) {
+      if (device != null && device.hasCapability<BatteryLevelStatus>()) {
         // Get the current battery level from the stream
-        final batteryLevel = await (device as BatteryLevelStatus)
+        final batteryLevel = await device.requireCapability<BatteryLevelStatus>()
             .batteryPercentageStream
             .first
             .timeout(
diff --git a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_device_row.dart b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_device_row.dart
diff --git a/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_view.dart b/open_wearable/lib/widgets/sensors/configuration/sensor_configuration_view.dart
diff --git a/open_wearable/lib/widgets/sensors/values/sensor_values_page.dart b/open_wearable/lib/widgets/sensors/values/sensor_values_page.dart

Original file line number	Diff line number	Diff line change
`@@ -194,18 +194,18 @@ class WearablesProvider with ChangeNotifier {`
`194`	`194`
`195`	`195`	`// 2) Slow/async work: run in microtasks so it doesn't block the add`
`196`	`196`	`// Stereo pairing (if applicable)`
`197`		`- if (wearable is StereoDevice) {`
`198`		`- _scheduleMicrotask(() => _maybeAutoPairStereoAsync(wearable as StereoDevice));`
	`197`	`+ if (wearable.hasCapability<StereoDevice>()) {`
	`198`	`+ _scheduleMicrotask(() => _maybeAutoPairStereoAsync(wearable.requireCapability<StereoDevice>()));`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`// Firmware support check (if applicable)`
`202`		`- if (wearable is DeviceFirmwareVersion) {`
`203`		`- _scheduleMicrotask(() => _maybeEmitUnsupportedFirmwareAsync(wearable as DeviceFirmwareVersion));`
	`202`	`+ if (wearable.hasCapability<DeviceFirmwareVersion>()) {`
	`203`	`+ _scheduleMicrotask(() => _maybeEmitUnsupportedFirmwareAsync(wearable.requireCapability<DeviceFirmwareVersion>()));`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`// Check for newer firmware (if applicable)`
`207`		`- if (wearable is DeviceFirmwareVersion) {`
`208`		`- _scheduleMicrotask(() => _checkForNewerFirmwareAsync(wearable as DeviceFirmwareVersion));`
	`207`	`+ if (wearable.hasCapability<DeviceFirmwareVersion>()) {`
	`208`	`+ _scheduleMicrotask(() => _checkForNewerFirmwareAsync(wearable.requireCapability<DeviceFirmwareVersion>()));`
`209`	`209`	`}`
`210`	`210`	`}`
`211`	`211`
`@@ -214,7 +214,7 @@ class WearablesProvider with ChangeNotifier {`
`214`	`214`	`void _ensureSensorConfigProvider(Wearable wearable) {`
`215`	`215`	`if (!_sensorConfigurationProviders.containsKey(wearable)) {`
`216`	`216`	`_sensorConfigurationProviders[wearable] = SensorConfigurationProvider(`
`217`		`- sensorConfigurationManager: wearable as SensorConfigurationManager,`
	`217`	`+ sensorConfigurationManager: wearable.requireCapability<SensorConfigurationManager>(),`
`218`	`218`	`);`
`219`	`219`	`}`
`220`	`220`	`}`