feat(trait_based): create new trait-based device detail screen

lib/devices/trait_based_device_screen.dart

@@ -0,0 +1,125 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:yonomi_device_widgets/providers/trait_based_device_notifier.dart';
+import 'package:yonomi_platform_sdk/yonomi-sdk.dart';
+import 'package:yonomi_platform_sdk/yonomi-sdk.dart' as yoSdk;
+
+class TraitBasedDetailScreen extends StatelessWidget {
+  final Request request;
+  final String deviceId;
+
+  const TraitBasedDetailScreen(
+      {Key? key, required this.request, required this.deviceId})
+      : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return ChangeNotifierProvider(
+      create: (_) => TraitBasedDeviceNotifier(request, deviceId),
+      child: Consumer<TraitBasedDeviceNotifier>(
+          builder: (_, traitBasedDeviceNotifier, child) {
+        if (traitBasedDeviceNotifier.deviceDetail == null) {
+          return CircularProgressIndicator();
+        } else {
+          return TraitWidgetsBuilder.build(
+              traitBasedDeviceNotifier.deviceDetail!);
+        }
+      }),
+    );
+  }
+}
+
+class isPowered extends yoSdk.State<bool> {
+  isPowered(bool isOn) : super("Power", isOn);
+}
+
+class PowerTrait extends Trait {
+  PowerTrait(String name, yoSdk.State state) : super(name, state);
+}
+
+class TraitWidgetsBuilder {
+  static Widget build(Device deviceDetail) {
+    List<Trait> dummyTraits = [
+      LockTrait("whenLocked", IsLocked(true)),
+      LockTrait("whenUnlocked", IsLocked(false)),
+      PowerTrait("PowerTrait", isPowered(true)),
+      UnknownTrait(),
+    ];
+
+    // TODO: L41: use deviceDetail.traits, not dummyTraits;
+    return Column(
+      children: [
+        buildDeviceTitleRow(deviceDetail.displayName),
+        ...buildTraitRows(dummyTraits),
+      ],
+    );
+  }
+
+  static Widget buildDeviceTitleRow(String deviceName) {
+    return Row(
+      children: [Text(deviceName)],
+    );
+  }
+
+  static List<Row> buildTraitRows(List<Trait> traits) {
+    List<Row> traitRows = [];
+    for (var trait in traits) {
+      traitRows.add(
+        Row(
+          children: [traitFactory(trait)],
+        ),
+      );
+    }
+    return traitRows;
+  }
+
+  static Widget traitFactory(Trait trait) {
+    switch (trait.runtimeType) {
+      case LockTrait:
+        return LockTraitWidget(trait);
+      case PowerTrait:
+        return PowerTraitWidget(trait);
+      default:
+        return UnknownTraitWidget(trait);
+    }
+  }
+}
+
+class LockTraitWidget extends StatelessWidget {
+  Trait trait;
+
+  LockTraitWidget(this.trait);
+
+  @override
+  Widget build(BuildContext context) {
+    return Text("Lock-based: ${this.trait.name}");
+  }
+}
+
+class PowerTraitWidget extends StatelessWidget {
+  Trait trait;
+
+  PowerTraitWidget(this.trait);
+
+  @override
+  Widget build(BuildContext context) {
+    return Text("Power Trait: ${this.trait.name}");
+    // return Switch(
+    //   value: false,
+    //   onChanged: (bool newValue) {
+    //     print("Switched ${newValue}");
+    //   },
+    // );
+  }
+}
+
+class UnknownTraitWidget extends StatelessWidget {
+  Trait trait;
+
+  UnknownTraitWidget(this.trait);
+
+  @override
+  Widget build(BuildContext context) {
+    return Text("Unknown Trait: ${this.trait.name}");
+  }
+}

lib/providers/trait_based_device_notifier.dart

@@ -0,0 +1,43 @@
+import 'package:flutter/material.dart';
+import 'package:yonomi_platform_sdk/yonomi-sdk.dart';
+
+typedef GetDetailsFunction = Future<Device> Function(
+    Request request, String id);
+
+class TraitBasedDeviceNotifier extends ChangeNotifier {
+  bool loadingDetail = false;
+
+  late String _deviceId;
+
+  late Request _request;
+
+  Device? _deviceDetail;
+
+  Device? get deviceDetail => _deviceDetail;
+
+  set deviceDetail(Device? detail) {
+    _deviceDetail = detail;
+    notifyListeners();
+  }
+
+  TraitBasedDeviceNotifier(Request request, String deviceId,
+      {GetDetailsFunction getDetails = DevicesRepository.getLockDetails}) {
+    _request = request;
+    _deviceId = deviceId;
+    fetchData(getDetails: getDetails);
+  }
+
+  Future<Device?> fetchData(
+      {GetDetailsFunction getDetails =
+          DevicesRepository.getLockDetails}) async {
+    loadingDetail = true;
+    notifyListeners();
+
+    _deviceDetail = await getDetails(_request, _deviceId);
+
+    loadingDetail = false;
+    notifyListeners();
+
+    return _deviceDetail;
+  }
+}