adjusted extremums and units due to additional data views

Author: OlehMarch

lib/src/analyser.dart

@@ -161,8 +161,6 @@ class AppAnalyser {
       batteryTemperature: _batteryTemperature.measurementUnit,
       cpuFrequency: _cpuFrequency.measurementUnit,
       cpuTemperature: _cpuTemperature.measurementUnit,
-      ramConsumption: _ramConsumption.measurementUnit,
-      trafficConsumption: _trafficConsumption.measurementUnit,
     );
   }
 }

lib/src/models/extremums.dart

@@ -13,9 +13,11 @@ abstract class AnalysisExtremumsInterface implements Encodable {
   Extremum<num> get batteryTemperature;
 
   Extremum<List<num>> get cpuFrequency;
+  Extremum<num> get cpuUsagePercents;
   Extremum<num> get cpuTemperature;
 
   Extremum<MemUnit> get ramConsumption;
+  Extremum<num> get ramConsumptionPercents;
 }
 
 class AnalysisExtremums implements AnalysisExtremumsInterface {
@@ -51,19 +53,27 @@ class AnalysisExtremums implements AnalysisExtremumsInterface {
   @override
   final Extremum<List<num>> cpuFrequency;
   @override
+  Extremum<num> get cpuUsagePercents => const Extremum(0, 100);
+  @override
   final Extremum<num> cpuTemperature;
 
   @override
   final Extremum<MemUnit> ramConsumption;
+  @override
+  Extremum<num> get ramConsumptionPercents => const Extremum(0, 100);
 
   @override
-  Map<String, dynamic> toMap() {
+  Map<String, dynamic> toMap({bool full = false}) {
     return {
       'batteryLevel': batteryLevel.toMap(),
       'batteryTemperature': batteryTemperature.toMap(),
       'cpuFrequency': cpuFrequency.toMap((value) => value),
       'cpuTemperature': cpuTemperature.toMap(),
       'ramConsumption': ramConsumption.toMap((value) => value.bytes),
+      if (full) ...{
+        'cpuUsagePercents': cpuUsagePercents.toMap(),
+        'ramConsumptionPercents': ramConsumptionPercents.toMap(),
+      }
     };
   }
 

lib/src/models/units.dart

@@ -13,9 +13,11 @@ abstract class AnalysisUnitsInterface implements Encodable {
   String get batteryTemperature;
 
   String get cpuFrequency;
+  String get cpuUsagePercents;
   String get cpuTemperature;
 
   MemVolUnit get ramConsumption;
+  String get ramConsumptionPercents;
 
   MemVolUnit get trafficConsumption;
 }
@@ -26,8 +28,6 @@ class AnalysisUnits implements AnalysisUnitsInterface {
     required this.batteryTemperature,
     required this.cpuFrequency,
     required this.cpuTemperature,
-    required this.ramConsumption,
-    required this.trafficConsumption,
   });
 
   factory AnalysisUnits.fromMap(Map<String, dynamic> map) {
@@ -36,8 +36,6 @@ class AnalysisUnits implements AnalysisUnitsInterface {
       batteryTemperature: map['batteryTemperature'],
       cpuFrequency: map['cpuFrequency'],
       cpuTemperature: map['cpuTemperature'],
-      ramConsumption: MemVolUnit(),
-      trafficConsumption: MemVolUnit(),
     );
   }
 
@@ -49,23 +47,31 @@ class AnalysisUnits implements AnalysisUnitsInterface {
   @override
   final String cpuFrequency;
   @override
+  String get cpuUsagePercents => '%';
+  @override
   final String cpuTemperature;
 
   @override
-  final MemVolUnit ramConsumption;
+  MemVolUnit get ramConsumption => MemVolUnit();
+  @override
+  String get ramConsumptionPercents => '%';
 
   @override
-  final MemVolUnit trafficConsumption;
+  MemVolUnit get trafficConsumption => MemVolUnit();
 
   @override
-  Map<String, dynamic> toMap() {
+  Map<String, dynamic> toMap({bool full = false}) {
     return {
       'batteryLevel': batteryLevel,
       'batteryTemperature': batteryTemperature,
       'cpuFrequency': cpuFrequency,
       'cpuTemperature': cpuTemperature,
-      'ramConsumption': ramConsumption.toString(),
-      'trafficConsumption': trafficConsumption.toString(),
+      if (full) ...{
+        'cpuUsagePercents': cpuUsagePercents,
+        'ramConsumption': ramConsumption.toString(),
+        'ramConsumptionPercents': ramConsumptionPercents,
+        'trafficConsumption': trafficConsumption.toString(),
+      },
     };
   }