feat: add windscreen wipers button (#63)

* fix: wait for package sending through USBDataSource(issue on desktop versions)
* chore: change bytes format to hex from int for raw incoming packages(when exporting logs)(resolves #54)
* chore: improve log file readability
* chore: format hex bytes everywhere to 0xHH format
* fix: add returning type to DialogRoutes from DeveloperTools
* feat: add windscreen wipers switch button(resolves #62)
* chore: increase logs cubit max records number to 500
* chore: v0.15.6+37

Author: radomir9720

lib/app/scopes/flows/selected_data_source_scope.dart

@@ -1,3 +1,5 @@
+import 'dart:math' as math;
+
 import 'package:auto_route/auto_route.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
@@ -6,6 +8,7 @@ import 'package:pixel_app_flutter/bootstrap.dart';
 import 'package:pixel_app_flutter/domain/app/storages/logger_storage.dart';
 import 'package:pixel_app_flutter/domain/apps/apps.dart';
 import 'package:pixel_app_flutter/domain/data_source/data_source.dart';
+import 'package:pixel_app_flutter/domain/data_source/extensions/int.dart';
 import 'package:pixel_app_flutter/domain/developer_tools/developer_tools.dart';
 import 'package:pixel_app_flutter/domain/user_defined_buttons/storages/user_defined_buttons_storage.dart';
 import 'package:pixel_app_flutter/l10n/l10n.dart';
@@ -21,6 +24,17 @@ class SelectedDataSourceScope extends AutoRouter {
   @override
   Widget Function(BuildContext context, Widget content)? get builder {
     return (context, content) {
+      String? inValidatedKey;
+      String? inRawKey;
+      String? inComposedKey;
+      String? outKey;
+      int? maxKeyLength;
+
+      int getKeysMaxLength() {
+        return [inValidatedKey, inRawKey, inComposedKey, outKey]
+            .fold<int>(0, (pr, curr) => math.max(curr?.length ?? 0, pr));
+      }
+
       return BlocBuilder<DataSourceCubit, DataSourceState>(
         builder: (context, state) {
           final dswa = state.ds.when(
@@ -48,6 +62,12 @@ class SelectedDataSourceScope extends AutoRouter {
               BlocProvider<DataSourceConnectionStatusCubit>(
                 create: (context) {
                   if (context.read<Environment>().isDev) {
+                    final dataSourceKey = context.read<DataSource>().key;
+                    inValidatedKey ??= 'InValidatedPackage($dataSourceKey)';
+                    inRawKey ??= 'InRaw($dataSourceKey)';
+                    inComposedKey ??= 'InComposedPackage($dataSourceKey)';
+                    outKey ??= 'OutPackage($dataSourceKey)';
+                    maxKeyLength ??= getKeysMaxLength();
                     context.read<DataSource>().addObserver(
                       (observable) {
                         observable.whenOrNull(
@@ -59,8 +79,8 @@ class SelectedDataSourceScope extends AutoRouter {
                                   DataSourceRequestDirection.incoming,
                                 );
                             context.read<LoggerStorage>().logInfo(
-                                  package.toString(),
-                                  'IncomingProcessedPackage',
+                                  package.toString(withDirection: false),
+                                  inValidatedKey.padLeftSpace(maxKeyLength),
                                 );
                           },
                           outgoingPackage: (package) {
@@ -75,8 +95,8 @@ class SelectedDataSourceScope extends AutoRouter {
                                   DataSourceRequestDirection.outgoing,
                                 );
                             context.read<LoggerStorage>().logInfo(
-                                  package.toString(),
-                                  'OutgoingPackage',
+                                  package.toString(withDirection: false),
+                                  outKey.padLeftSpace(maxKeyLength),
                                 );
                           },
                           rawIncomingBytes: (bytes) {
@@ -85,8 +105,8 @@ class SelectedDataSourceScope extends AutoRouter {
                                   DataSourceRequestDirection.incoming,
                                 );
                             context.read<LoggerStorage>().logInfo(
-                                  bytes.toString(),
-                                  'IncomingRawBytes',
+                                  bytes.toFormattedHexString,
+                                  inRawKey.padLeftSpace(maxKeyLength),
                                 );
                           },
                           rawIncomingPackage: (bytes) {
@@ -95,8 +115,8 @@ class SelectedDataSourceScope extends AutoRouter {
                                   DataSourceRequestDirection.incoming,
                                 );
                             context.read<LoggerStorage>().logInfo(
-                                  bytes.toString(),
-                                  'IncomingRawPackage',
+                                  bytes.toFormattedHexString,
+                                  inComposedKey.padLeftSpace(maxKeyLength),
                                 );
                           },
                         );
@@ -134,11 +154,12 @@ class SelectedDataSourceScope extends AutoRouter {
                 lazy: false,
               ),
               BlocProvider(
-                create: (context) => DoorsCubit(
+                create: (context) => GeneralInterfacesCubit(
                   dataSource: context.read(),
                 )
                   ..subscribeToLeftDoor()
-                  ..subscribeToRightDoor(),
+                  ..subscribeToRightDoor()
+                  ..subscribeToWindscreenWipers(),
               ),
               BlocProvider(
                 create: (context) {
@@ -197,3 +218,7 @@ class SelectedDataSourceScope extends AutoRouter {
     };
   }
 }
+
+extension on String? {
+  String padLeftSpace(int? width) => this?.padLeft(width ?? 0) ?? '';
+}

lib/data/services/data_source/demo_data_source.dart

@@ -375,6 +375,11 @@ class DemoDataSource extends DataSource
               const CustomImageParameterId(),
             );
           })
+          ..voidOn<WindscreenWipersParameterId>(() {
+            _sendSetBoolUint8ResultCallback(
+              const WindscreenWipersParameterId(),
+            );
+          })
           ..voidOn<CustomParameterId>(() {
             switch (parameterId.value) {
               case 0x00E0:
@@ -568,6 +573,12 @@ class DemoDataSource extends DataSource
           package.boolData,
         );
       })
+      ..voidOn<WindscreenWipersParameterId>(() {
+        _sendSetBoolUint8ResultCallback(
+          const WindscreenWipersParameterId(),
+          package.boolData,
+        );
+      })
       ..voidOn<CustomImageParameterId>(() {
         _sendSetUint8ResultCallback(
           const CustomImageParameterId(),

lib/data/services/data_source/usb_data_source.dart

@@ -83,7 +83,7 @@ class USBDataSource extends DataSource
 
     observeOutgoing(package);
 
-    sp.write(package.toUint8List);
+    sp.write(package.toUint8List, timeout: 0);
 
     return const Result.value(null);
   }

lib/domain/data_source/blocs/doors_cubit.dart renamed to lib/domain/data_source/blocs/general_interfaces_cubit.dart

@@ -7,52 +7,68 @@ import 'package:pixel_app_flutter/domain/data_source/models/package/outgoing/out
 import 'package:pixel_app_flutter/domain/data_source/models/package_data/package_data.dart';
 import 'package:re_seedwork/re_seedwork.dart';
 
-typedef DoorState = AsyncData<bool, ToggleStateError>;
+typedef GeneralInterfaceState = AsyncData<bool, ToggleStateError>;
 
 @immutable
-class DoorsState with EquatableMixin {
-  const DoorsState({required this.left, required this.right});
+class GeneralInterfacesState with EquatableMixin {
+  const GeneralInterfacesState({
+    required this.leftDoor,
+    required this.rightDoor,
+    required this.wipers,
+  });
 
-  const DoorsState.initial()
-      : left = const AsyncData.initial(false),
-        right = const AsyncData.initial(false);
+  const GeneralInterfacesState.initial()
+      : leftDoor = const AsyncData.initial(false),
+        rightDoor = const AsyncData.initial(false),
+        wipers = const AsyncData.initial(false);
 
-  final DoorState left;
-  final DoorState right;
+  final GeneralInterfaceState leftDoor;
+  final GeneralInterfaceState rightDoor;
+  final GeneralInterfaceState wipers;
 
   @override
-  List<Object?> get props => [left, right];
+  List<Object?> get props => [leftDoor, rightDoor, wipers];
 
-  DoorsState copyWith({
-    DoorState? left,
-    DoorState? right,
+  GeneralInterfacesState copyWith({
+    GeneralInterfaceState? leftDoor,
+    GeneralInterfaceState? rightDoor,
+    GeneralInterfaceState? wipers,
   }) {
-    return DoorsState(
-      left: left ?? this.left,
-      right: right ?? this.right,
+    return GeneralInterfacesState(
+      leftDoor: leftDoor ?? this.leftDoor,
+      rightDoor: rightDoor ?? this.rightDoor,
+      wipers: wipers ?? this.wipers,
     );
   }
 
-  bool get hasFailureState => [left, right].any((element) => element.isFailure);
+  bool get hasFailureState =>
+      [leftDoor, rightDoor, wipers].any((element) => element.isFailure);
 
   List<R> whenFailure<R>(
-    DoorsState prevState, {
-    required R Function(ToggleStateError error) left,
-    required R Function(ToggleStateError error) right,
+    GeneralInterfacesState prevState, {
+    required R Function(ToggleStateError error) leftDoor,
+    required R Function(ToggleStateError error) rightDoor,
+    required R Function(ToggleStateError error) wipers,
   }) {
-    final leftError = this.left.error;
-    final rightError = this.right.error;
+    final leftError = this.leftDoor.error;
+    final rightError = this.rightDoor.error;
+    final wipersError = this.wipers.error;
 
     final errors = [
       _filterError(
         leftError,
-        prevState.left.error,
-        left,
+        prevState.leftDoor.error,
+        leftDoor,
       ),
       _filterError(
         rightError,
-        prevState.right.error,
-        right,
+        prevState.rightDoor.error,
+        rightDoor,
+      ),
+      _filterError(
+        wipersError,
+        prevState.wipers.error,
+        wipers,
       ),
     ].whereType<R>().toList();
 
@@ -78,19 +94,24 @@ extension _ErrorExtension<V, E extends Object> on AsyncData<V, E> {
       );
 }
 
-class DoorsCubit extends Cubit<DoorsState> with ConsumerBlocMixin {
-  DoorsCubit({
+class GeneralInterfacesCubit extends Cubit<GeneralInterfacesState>
+    with ConsumerBlocMixin {
+  GeneralInterfacesCubit({
     required this.dataSource,
     this.subscriptionTimeout = kSubscriptionTimeout,
     this.toggleTimeout = kToggleTimeout,
-  }) : super(const DoorsState.initial()) {
+  }) : super(const GeneralInterfacesState.initial()) {
     subscribe<DataSourceIncomingPackage>(dataSource.packageStream, (package) {
       package
         ..voidOnModel<DoorBody, LeftDoorIncomingDataSourcePackage>((model) {
-          emit(state.copyWith(left: AsyncData.success(model.isOpen)));
+          emit(state.copyWith(leftDoor: AsyncData.success(model.isOpen)));
         })
         ..voidOnModel<DoorBody, RightDoorIncomingDataSourcePackage>((model) {
-          emit(state.copyWith(right: AsyncData.success(model.isOpen)));
+          emit(state.copyWith(rightDoor: AsyncData.success(model.isOpen)));
+        })
+        ..voidOnModel<WindscreenWipersBody,
+            WindscreenWipersIncomingDataSourcePackage>((model) {
+          emit(state.copyWith(wipers: AsyncData.success(model.isOn)));
         });
     });
   }
@@ -115,8 +136,8 @@ class DoorsCubit extends Cubit<DoorsState> with ConsumerBlocMixin {
         const DataSourceParameterId.custom(ButtonFunctionId.leftDoorId),
   ]) {
     _subscribe(
-      newStateBuilder: (newState) => state.copyWith(left: newState),
-      newFeatureStateBuilder: () => state.left,
+      newStateBuilder: (newState) => state.copyWith(leftDoor: newState),
+      newFeatureStateBuilder: () => state.leftDoor,
       parameterId: parameterId,
     );
   }
@@ -126,14 +147,25 @@ class DoorsCubit extends Cubit<DoorsState> with ConsumerBlocMixin {
         const DataSourceParameterId.custom(ButtonFunctionId.rightDoorId),
   ]) {
     _subscribe(
-      newStateBuilder: (newState) => state.copyWith(right: newState),
-      newFeatureStateBuilder: () => state.right,
+      newStateBuilder: (newState) => state.copyWith(rightDoor: newState),
+      newFeatureStateBuilder: () => state.rightDoor,
+      parameterId: parameterId,
+    );
+  }
+
+  void subscribeToWindscreenWipers({
+    DataSourceParameterId parameterId =
+        const DataSourceParameterId.windscreenWipers(),
+  }) {
+    _subscribe(
+      newStateBuilder: (newState) => state.copyWith(wipers: newState),
+      newFeatureStateBuilder: () => state.wipers,
       parameterId: parameterId,
     );
   }
 
   Future<void> _subscribe({
-    required DoorsState Function(
+    required GeneralInterfacesState Function(
       AsyncData<bool, ToggleStateError> newState,
     ) newStateBuilder,
     required AsyncData<bool, ToggleStateError> Function()
@@ -148,7 +180,7 @@ class DoorsCubit extends Cubit<DoorsState> with ConsumerBlocMixin {
 
     final failure = await stream
         .where((event) => newFeatureStateBuilder().isExecuted)
-        .map<DoorsState?>((event) => null)
+        .map<GeneralInterfacesState?>((event) => null)
         .first
         .timeout(
       subscriptionTimeout,
@@ -169,43 +201,59 @@ class DoorsCubit extends Cubit<DoorsState> with ConsumerBlocMixin {
     DataSourceParameterId parameterId = const DataSourceParameterId.leftDoor(),
   ]) {
     _toggleBool(
-      newFeatureStateBuilder: () => state.left,
-      newStateBuilder: (newState) => state.copyWith(left: newState),
-      parameterId: parameterId,
+      newFeatureStateBuilder: () => state.leftDoor,
+      newStateBuilder: (newState) => state.copyWith(leftDoor: newState),
+      outgoingPackageBuilder: (_) =>
+          OutgoingActionRequestPackage(parameterId: parameterId),
     );
   }
 
   void toggleRightDoor([
     DataSourceParameterId parameterId = const DataSourceParameterId.rightDoor(),
   ]) {
     _toggleBool(
-      newFeatureStateBuilder: () => state.right,
-      newStateBuilder: (newState) => state.copyWith(right: newState),
-      parameterId: parameterId,
+      newFeatureStateBuilder: () => state.rightDoor,
+      newStateBuilder: (newState) => state.copyWith(rightDoor: newState),
+      outgoingPackageBuilder: (_) =>
+          OutgoingActionRequestPackage(parameterId: parameterId),
+    );
+  }
+
+  void toggleWindscreenWipers([
+    DataSourceParameterId parameterId =
+        const DataSourceParameterId.windscreenWipers(),
+  ]) {
+    _toggleBool(
+      newFeatureStateBuilder: () => state.wipers,
+      newStateBuilder: (newState) => state.copyWith(wipers: newState),
+      outgoingPackageBuilder: (setTo) => OutgoingSetValuePackage(
+        parameterId: parameterId,
+        setValueBody: SetUint8Body(value: setTo ? 0xFF : 0),
+      ),
     );
   }
 
   Future<void> _toggleBool({
     required AsyncData<bool, ToggleStateError> Function()
         newFeatureStateBuilder,
-    required DoorsState Function(
+    required GeneralInterfacesState Function(
       AsyncData<bool, ToggleStateError> newState,
     ) newStateBuilder,
-    required DataSourceParameterId parameterId,
+    // ignore: avoid_positional_boolean_parameters
+    required DataSourceOutgoingPackage Function(bool setTo)
+        outgoingPackageBuilder,
   }) async {
     final currentState = newFeatureStateBuilder();
     if (!currentState.isExecuted) return;
 
     final setTo = !currentState.payload;
     emit(newStateBuilder(AsyncData.loading(setTo)));
 
-    await dataSource.sendPackage(
-      OutgoingActionRequestPackage(parameterId: parameterId),
-    );
+    await dataSource.sendPackage(outgoingPackageBuilder(setTo));
 
     final failure = await stream
         .where((event) => newFeatureStateBuilder().payload == setTo)
-        .map<DoorState?>((event) => null)
+        .map<GeneralInterfaceState?>((event) => null)
         .first
         .timeout(
       toggleTimeout,