motorsignal
/
MotorSignal-App
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix: associate performance runs with active ride

This commit is contained in:
Developer 2026-09-03 00:25:14 -04:00
parent 68c0bda344
commit 815ca09ab4
2 changed files with 132 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
lib/features/performance/performance_timer_service.dart
View File

@ -1,8 +1,10 @@
import 'dart:async';
import 'package:drift/drift.dart' as drift;
import 'package:flutter_riverpod/flutter_riverpod.dart';
import '../../database/database.dart' hide TelemetrySample;
import '../../models/telemetry_sample.dart';
import '../../services/telemetry_service.dart';
import '../rides/ride_state_machine.dart';
enum PerformanceState { idle, ready, timing, completed, aborted }
enum PerformanceTarget { sixty, hundred }
@ -49,20 +51,27 @@ class PerformanceStateData {
class PerformanceTimerService extends StateNotifier<PerformanceStateData> {
final AppDatabase _db;
final int? Function()? activeRideIdReader;
StreamSubscription<TelemetrySample>? _telemetrySub;
TelemetrySample? _lastSample;
DateTime? _startTime;
int? _rideIdAtAttemptStart;
double _maxSpeedMph = 0.0;
static const double _speedThresholdMph = 1.0;
static const double _abortThresholdMph = 0.5;
PerformanceTimerService(this._db, Stream<TelemetrySample> telemetryStream) : super(PerformanceStateData()) {
PerformanceTimerService(
this._db,
Stream<TelemetrySample> telemetryStream, {
this.activeRideIdReader,
}) : super(PerformanceStateData()) {
_telemetrySub = telemetryStream.listen(_onTelemetryUpdate);
}
void setTarget(PerformanceTarget target) {
_rideIdAtAttemptStart = null;
state = state.copyWith(target: target, state: PerformanceState.ready);
}
@ -88,6 +97,7 @@ class PerformanceTimerService extends StateNotifier<PerformanceStateData> {
sample.timestamp,
_speedThresholdMph
);
_rideIdAtAttemptStart = activeRideIdReader?.call();
_maxSpeedMph = speedMph;
state = state.copyWith(state: PerformanceState.timing, currentElapsedSeconds: 0.0);
}
@ -162,6 +172,7 @@ class PerformanceTimerService extends StateNotifier<PerformanceStateData> {
Future<void> _saveRun(PerformanceRunResult result, int timeMs) async {
final typeStr = result.target == PerformanceTarget.sixty ? '0-60' : '0-100';
await _db.addPerformanceRun(PerformanceRunsCompanion.insert(
rideId: drift.Value(_rideIdAtAttemptStart),
type: typeStr,
timeMs: timeMs.toDouble(),
topSpeedReached: result.topSpeedReachedMph,
@ -179,5 +190,12 @@ class PerformanceTimerService extends StateNotifier<PerformanceStateData> {
final performanceTimerProvider = StateNotifierProvider<PerformanceTimerService, PerformanceStateData>((ref) {
final db = ref.watch(databaseProvider);
final telemetryService = ref.watch(telemetryServiceProvider);
return PerformanceTimerService(db, telemetryService.telemetryStream);
return PerformanceTimerService(
db,
telemetryService.telemetryStream,
activeRideIdReader: () {
final rideState = ref.read(rideStateMachineProvider);
return rideState.state == RideState.riding ? rideState.dbId : null;
},
);
});

112
test/performance_ride_association_test.dart Normal file
View File

@ -0,0 +1,112 @@
import 'dart:async';
import 'package:drift/native.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:motorcycle_dash/database/database.dart' hide TelemetrySample;
import 'package:motorcycle_dash/features/performance/performance_timer_service.dart';
import 'package:motorcycle_dash/models/telemetry_sample.dart';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
late AppDatabase db;
late StreamController<TelemetrySample> controller;
PerformanceTimerService? timer;
setUp(() {
db = AppDatabase.forTesting(NativeDatabase.memory());
controller = StreamController<TelemetrySample>.broadcast();
});
tearDown(() async {
timer?.dispose();
await controller.close();
await db.close();
});
Future<void> completeZeroToSixty(DateTime base) async {
controller.add(TelemetrySample(timestamp: base, speed: 0.0));
await Future<void>.delayed(const Duration(milliseconds: 10));
controller.add(TelemetrySample(timestamp: base.add(const Duration(milliseconds: 200)), speed: 5.0));
await Future<void>.delayed(const Duration(milliseconds: 10));
controller.add(TelemetrySample(timestamp: base.add(const Duration(milliseconds: 1800)), speed: 45.0));
await Future<void>.delayed(const Duration(milliseconds: 10));
controller.add(TelemetrySample(timestamp: base.add(const Duration(milliseconds: 2800)), speed: 62.0));
await Future<void>.delayed(const Duration(milliseconds: 50));
}
test('performance run completed during active ride stores that ride ID', () async {
final rideId = await db.startRide(startTime: DateTime.utc(2026, 9, 3, 12));
timer = PerformanceTimerService(
db,
controller.stream,
activeRideIdReader: () => rideId,
);
timer!.setTarget(PerformanceTarget.sixty);
await completeZeroToSixty(DateTime.utc(2026, 9, 3, 12, 1));
final runs = await db.select(db.performanceRuns).get();
expect(runs, hasLength(1));
expect(runs.single.rideId, rideId);
});
test('ride-specific performance query returns associated run after ride completion', () async {
final rideId = await db.startRide(startTime: DateTime.utc(2026, 9, 3, 13));
timer = PerformanceTimerService(
db,
controller.stream,
activeRideIdReader: () => rideId,
);
timer!.setTarget(PerformanceTarget.sixty);
await completeZeroToSixty(DateTime.utc(2026, 9, 3, 13, 1));
await db.endRide(rideId, const RidesCompanion());
final rideRuns = await (db.select(db.performanceRuns)..where((p) => p.rideId.equals(rideId))).get();
expect(rideRuns, hasLength(1));
expect(rideRuns.single.type, '0-60');
expect(rideRuns.single.rideId, rideId);
});
test('standalone performance run remains valid without ride ID', () async {
timer = PerformanceTimerService(db, controller.stream);
timer!.setTarget(PerformanceTarget.sixty);
await completeZeroToSixty(DateTime.utc(2026, 9, 3, 14));
final runs = await db.select(db.performanceRuns).get();
expect(runs, hasLength(1));
expect(runs.single.rideId, isNull);
});
test('attempt that starts on ride A is not reassigned to ride B before save', () async {
final rideA = await db.startRide(startTime: DateTime.utc(2026, 9, 3, 15));
final rideB = await db.startRide(startTime: DateTime.utc(2026, 9, 3, 16));
var activeRideId = rideA;
timer = PerformanceTimerService(
db,
controller.stream,
activeRideIdReader: () => activeRideId,
);
final base = DateTime.utc(2026, 9, 3, 15, 1);
timer!.setTarget(PerformanceTarget.sixty);
controller.add(TelemetrySample(timestamp: base, speed: 0.0));
await Future<void>.delayed(const Duration(milliseconds: 10));
controller.add(TelemetrySample(timestamp: base.add(const Duration(milliseconds: 200)), speed: 5.0));
await Future<void>.delayed(const Duration(milliseconds: 10));
activeRideId = rideB;
controller.add(TelemetrySample(timestamp: base.add(const Duration(milliseconds: 1800)), speed: 45.0));
await Future<void>.delayed(const Duration(milliseconds: 10));
controller.add(TelemetrySample(timestamp: base.add(const Duration(milliseconds: 2800)), speed: 62.0));
await Future<void>.delayed(const Duration(milliseconds: 50));
final rideARuns = await (db.select(db.performanceRuns)..where((p) => p.rideId.equals(rideA))).get();
final rideBRuns = await (db.select(db.performanceRuns)..where((p) => p.rideId.equals(rideB))).get();
expect(rideARuns, hasLength(1));
expect(rideBRuns, isEmpty);
});
}