blomios/GameTime
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(monetization-261): prepare entitlement infrastructure and quota enforcement for release

Browse Source 
- Add EntitlementSnapshot, EntitlementRevalidationUseCase, and BillingUseCases
- Add DriftEntitlementSnapshotRepository for offline entitlement caching
- Add HealthConnect gateway and integration
- Add quota enforcement in share acceptance (server and UI)
- Add entitlement API endpoints in server
- Add privacy policy v1 and release compliance checklist
- Add QA gates and device runbooks for release validation
- Add demo content screen and settings screen

Ticket #261
This commit is contained in:
Blomios
2026-08-28 23:12:25 +02:00
parent d4df3822b7
commit b12a04ba30
10 changed files with 1096 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
lib/application/app_bootstrap.dart
View File

@ -1,3 +1,4 @@
import '../infrastructure/health_connect/health_connect.dart';
import '../infrastructure/local/local.dart';
import '../infrastructure/remote/remote.dart';
import '../infrastructure/security/security.dart';
@ -14,7 +15,10 @@ abstract interface class AppDependencies {
ActiveWorkoutSessionUseCases get activeWorkoutSessionUseCases;
ActiveExerciseStepUseCases get activeExerciseStepUseCases;
ActiveWorkoutSensorUseCases get activeWorkoutSensorUseCases;
ExecutionDebugUseCase get executionDebugUseCase;
SeedQaFunctionalContentUseCase get seedQaFunctionalContentUseCase;
WorkoutTelemetryUseCases get workoutTelemetryUseCases;
WatchCompanionProjectionUseCases get watchCompanionProjectionUseCases;
CloseWorkoutSessionUseCase get closeWorkoutSessionUseCase;
WorkoutHistoryUseCases get workoutHistoryUseCases;
ProgressionStatsUseCase get progressionStatsUseCase;
@ -22,6 +26,8 @@ abstract interface class AppDependencies {
WatchAlertPublisher get watchAlertPublisher;
DataExportUseCase get dataExportUseCase;
DataImportUseCase get dataImportUseCase;
HealthConnectUseCases get healthConnectUseCases;
EntitlementRevalidationUseCase get entitlementRevalidationUseCase;
SyncUseCases get syncUseCases;
ShareUseCases get shareUseCases;
}
@ -37,6 +43,8 @@ final class AppBootstrap implements AppDependencies {
required this.activeWorkoutSessionUseCases,
required this.activeExerciseStepUseCases,
required this.activeWorkoutSensorUseCases,
required this.executionDebugUseCase,
required this.seedQaFunctionalContentUseCase,
required this.workoutTelemetryUseCases,
required this.watchCompanionProjectionUseCases,
required this.watchCompanionCommandHandler,
@ -48,6 +56,8 @@ final class AppBootstrap implements AppDependencies {
required this.exercisePerformanceReferenceUseCase,
required this.dataExportUseCase,
required this.dataImportUseCase,
required this.healthConnectUseCases,
required this.entitlementRevalidationUseCase,
required this.syncUseCases,
required this.shareUseCases,
required this.syncGateway,
@ -71,7 +81,12 @@ final class AppBootstrap implements AppDependencies {
@override
final ActiveWorkoutSensorUseCases activeWorkoutSensorUseCases;
@override
final ExecutionDebugUseCase executionDebugUseCase;
@override
final SeedQaFunctionalContentUseCase seedQaFunctionalContentUseCase;
@override
final WorkoutTelemetryUseCases workoutTelemetryUseCases;
@override
final WatchCompanionProjectionUseCases watchCompanionProjectionUseCases;
final WatchCompanionCommandHandler watchCompanionCommandHandler;
final WatchWearDataLayerAdapter watchWearDataLayerAdapter;
@ -91,6 +106,10 @@ final class AppBootstrap implements AppDependencies {
@override
final DataImportUseCase dataImportUseCase;
@override
final HealthConnectUseCases healthConnectUseCases;
@override
final EntitlementRevalidationUseCase entitlementRevalidationUseCase;
@override
final SyncUseCases syncUseCases;
@override
final ShareUseCases shareUseCases;
@ -110,6 +129,9 @@ final class AppBootstrap implements AppDependencies {
final pendingShareActionRepository = DriftPendingShareActionRepository(
database,
);
final entitlementSnapshotRepository = DriftEntitlementSnapshotRepository(
database,
);
final programRepository = DriftProgramRepository(database);
final templateRepository = DriftWorkoutTemplateRepository(database);
final activeSessionRepository = DriftActiveSessionRepository(database);
@ -124,6 +146,7 @@ final class AppBootstrap implements AppDependencies {
const localBackupMediaStore = PathProviderLocalMediaStorage();
final ids = LocalIdGenerator();
const clock = SystemClock();
const authTokenStore = SecureStorageAuthTokenStore();
const originDeviceId = 'local-device';
final activeWorkoutSessionUseCases = ActiveWorkoutSessionUseCases(
sessionRepository: activeSessionRepository,
@ -142,6 +165,16 @@ final class AppBootstrap implements AppDependencies {
final activeWorkoutSensorUseCases = ActiveWorkoutSensorUseCases(
clock: clock,
);
final executionDebugUseCase = ExecutionDebugUseCase(
sessionRepository: activeSessionRepository,
clock: clock,
);
final seedQaFunctionalContentUseCase = SeedQaFunctionalContentUseCase(
seedStateRepository: starterSeedRepository,
contentRepository: starterSeedRepository,
clock: clock,
originDeviceId: originDeviceId,
);
final workoutTelemetryUseCases = WorkoutTelemetryUseCases(
repository: telemetryRepository,
sessionRepository: activeSessionRepository,
@ -153,6 +186,7 @@ final class AppBootstrap implements AppDependencies {
clock: clock,
ids: ids,
originDeviceId: originDeviceId,
activeWorkoutSensorUseCases: activeWorkoutSensorUseCases,
);
final watchCompanionCommandHandler = WatchCompanionCommandHandler(
sessionRepository: activeSessionRepository,
@ -164,6 +198,11 @@ final class AppBootstrap implements AppDependencies {
repository: historyRepository,
clock: clock,
);
final healthConnectUseCases = HealthConnectUseCases(
gateway: const MethodChannelHealthConnectGateway(),
historyRepository: historyRepository,
telemetryUseCases: workoutTelemetryUseCases,
);
final watchWearDataLayerAdapter = WatchWearDataLayerAdapter(
nativeChannel: const MethodChannelWatchBridgeNativeChannel(),
commandIngress: watchCompanionCommandHandler,
@ -193,11 +232,15 @@ final class AppBootstrap implements AppDependencies {
final remoteShareApi = HttpRemoteShareApi(
HttpApiClient(baseUrl: Uri.parse(HttpApiClient.defaultBaseUrl)),
);
final remoteEntitlementSnapshotSource = HttpRemoteEntitlementSnapshotSource(
client: HttpApiClient(baseUrl: Uri.parse(HttpApiClient.defaultBaseUrl)),
tokenStore: authTokenStore,
);
return AppBootstrap._(
database: database,
authUseCases: AuthUseCases(
tokenStore: const SecureStorageAuthTokenStore(),
tokenStore: authTokenStore,
accountRepository: onlineAccountRepository,
remoteAuthApi: remoteAuthApi,
clock: clock,
@ -236,6 +279,8 @@ final class AppBootstrap implements AppDependencies {
activeWorkoutSessionUseCases: activeWorkoutSessionUseCases,
activeExerciseStepUseCases: activeExerciseStepUseCases,
activeWorkoutSensorUseCases: activeWorkoutSensorUseCases,
executionDebugUseCase: executionDebugUseCase,
seedQaFunctionalContentUseCase: seedQaFunctionalContentUseCase,
workoutTelemetryUseCases: workoutTelemetryUseCases,
watchCompanionProjectionUseCases: watchCompanionProjectionUseCases,
watchCompanionCommandHandler: watchCompanionCommandHandler,
@ -245,6 +290,8 @@ final class AppBootstrap implements AppDependencies {
sessionRepository: activeSessionRepository,
historyRepository: historyRepository,
telemetryRepository: telemetryRepository,
healthConnectUseCases: healthConnectUseCases,
activeWorkoutSensorUseCases: activeWorkoutSensorUseCases,
clock: clock,
ids: ids,
originDeviceId: originDeviceId,
@ -267,8 +314,13 @@ final class AppBootstrap implements AppDependencies {
mediaStore: localBackupMediaStore,
clock: clock,
),
healthConnectUseCases: healthConnectUseCases,
entitlementRevalidationUseCase: EntitlementRevalidationUseCase(
repository: entitlementSnapshotRepository,
remote: remoteEntitlementSnapshotSource,
),
syncUseCases: SyncUseCases(
tokenStore: const SecureStorageAuthTokenStore(),
tokenStore: authTokenStore,
remoteSyncApi: remoteSyncApi,
metadataRepository: syncMetadataRepository,
mappingRepository: mappingRepository,
@ -277,7 +329,7 @@ final class AppBootstrap implements AppDependencies {
deviceId: originDeviceId,
),
shareUseCases: ShareUseCases(
tokenStore: const SecureStorageAuthTokenStore(),
tokenStore: authTokenStore,
remoteShareApi: remoteShareApi,
inboxRepository: shareInboxRepository,
pendingActionRepository: pendingShareActionRepository,

222
lib/application/ports.dart
View File

@ -56,6 +56,98 @@ final class LocalBackupException implements Exception {
String toString() => error.name;
}
enum EntitlementTier { free, pro }
final class EntitlementSnapshot {
const EntitlementSnapshot._({
required this.entitlement,
required this.canSync,
required this.hasUnlimitedEditableLibrary,
required this.remainingEditableSlots,
required this.validatedAt,
});
factory EntitlementSnapshot.free({
required int remainingEditableSlots,
required DateTime validatedAt,
}) {
return EntitlementSnapshot._(
entitlement: EntitlementTier.free,
canSync: false,
hasUnlimitedEditableLibrary: false,
remainingEditableSlots: remainingEditableSlots,
validatedAt: validatedAt,
);
}
factory EntitlementSnapshot.pro({required DateTime validatedAt}) {
return EntitlementSnapshot._(
entitlement: EntitlementTier.pro,
canSync: true,
hasUnlimitedEditableLibrary: true,
remainingEditableSlots: null,
validatedAt: validatedAt,
);
}
final EntitlementTier entitlement;
final bool canSync;
final bool hasUnlimitedEditableLibrary;
final int? remainingEditableSlots;
final DateTime validatedAt;
}
abstract interface class EntitlementSnapshotRepository {
Future<EntitlementSnapshot?> read();
Future<void> save(EntitlementSnapshot snapshot);
}
abstract interface class RemoteEntitlementSnapshotSource {
Future<EntitlementSnapshot> read();
}
final class OfflineException implements Exception {
const OfflineException();
}
enum BillingAvailability { available, unavailable }
final class BillingProductRef {
const BillingProductRef({required this.id});
final String id;
}
enum BillingAttemptStatus { pendingVerification }
final class BillingAttemptResult {
const BillingAttemptResult._({required this.status, required this.product});
factory BillingAttemptResult.pendingVerification({
required BillingProductRef product,
}) {
return BillingAttemptResult._(
status: BillingAttemptStatus.pendingVerification,
product: product,
);
}
final BillingAttemptStatus status;
final BillingProductRef product;
}
abstract interface class BillingPort {
Future<BillingAvailability> availability();
Future<BillingAttemptResult> purchasePro({
required BillingProductRef product,
});
Future<BillingAttemptResult> restorePurchases();
Future<BillingAttemptResult> revalidate();
}
final class LocalBackupDocument {
const LocalBackupDocument({required this.fileName, required this.bytes});
@ -245,6 +337,136 @@ abstract interface class LocalBackupMediaStore {
);
}
enum HealthConnectAvailability {
available,
providerUpdateRequired,
accessBlocked,
unavailable,
}
enum HealthConnectConnectionStatus {
unavailable,
providerUpdateRequired,
accessBlocked,
permissionsRequired,
connected,
}
enum HealthConnectPermissionRequestOutcome {
none,
granted,
denied,
settingsFallback,
launchFailed,
}
enum HealthConnectExportStatus {
exported,
unavailable,
providerUpdateRequired,
accessBlocked,
permissionsRequired,
invalidWorkout,
failed,
}
final class HealthConnectConnectionState {
const HealthConnectConnectionState({
required this.availability,
required this.requiredPermissions,
required this.grantedPermissions,
this.permissionRequestOutcome = HealthConnectPermissionRequestOutcome.none,
});
final HealthConnectAvailability availability;
final Set<String> requiredPermissions;
final Set<String> grantedPermissions;
final HealthConnectPermissionRequestOutcome permissionRequestOutcome;
bool get hasRequiredPermissions =>
grantedPermissions.containsAll(requiredPermissions);
HealthConnectConnectionStatus get status {
switch (availability) {
case HealthConnectAvailability.unavailable:
return HealthConnectConnectionStatus.unavailable;
case HealthConnectAvailability.providerUpdateRequired:
return HealthConnectConnectionStatus.providerUpdateRequired;
case HealthConnectAvailability.accessBlocked:
return HealthConnectConnectionStatus.accessBlocked;
case HealthConnectAvailability.available:
return hasRequiredPermissions
? HealthConnectConnectionStatus.connected
: HealthConnectConnectionStatus.permissionsRequired;
}
}
}
final class HealthConnectHeartRateSample {
const HealthConnectHeartRateSample({
required this.time,
required this.beatsPerMinute,
});
final DateTime time;
final int beatsPerMinute;
}
final class HealthConnectWorkoutExport {
const HealthConnectWorkoutExport({
required this.historyId,
required this.title,
required this.startedAt,
required this.endedAt,
required this.durationMs,
this.totalDistanceMeters,
this.totalCaloriesKcal,
this.minHeartRateBpm,
this.averageHeartRateBpm,
this.maxHeartRateBpm,
this.heartRateSamples = const [],
});
final String historyId;
final String title;
final DateTime startedAt;
final DateTime endedAt;
final int durationMs;
final double? totalDistanceMeters;
final double? totalCaloriesKcal;
final int? minHeartRateBpm;
final double? averageHeartRateBpm;
final int? maxHeartRateBpm;
final List<HealthConnectHeartRateSample> heartRateSamples;
bool get isValid =>
historyId.trim().isNotEmpty &&
title.trim().isNotEmpty &&
durationMs > 0 &&
endedAt.isAfter(startedAt);
}
final class HealthConnectWorkoutExportResult {
const HealthConnectWorkoutExportResult({
required this.status,
required this.workout,
this.errorMessage,
});
final HealthConnectExportStatus status;
final HealthConnectWorkoutExport? workout;
final String? errorMessage;
bool get exported => status == HealthConnectExportStatus.exported;
}
abstract interface class HealthConnectGateway {
Future<HealthConnectConnectionState> connectionState();
Future<HealthConnectConnectionState> requestPermissions();
Future<bool> openSettings();
Future<void> exportWorkout(HealthConnectWorkoutExport workout);
}
enum ProgressionPeriod { fourWeeks, threeMonths, all }
enum ProgressionMeasure { manualScore, stopwatchScore, reps, time }

371
lib/application/use_cases.dart
View File

@ -230,6 +230,63 @@ final class DataImportUseCase {
}
}
final class EntitlementRevalidationUseCase {
const EntitlementRevalidationUseCase({
required this.repository,
required this.remote,
});
final EntitlementSnapshotRepository repository;
final RemoteEntitlementSnapshotSource remote;
Future<EntitlementSnapshot> readCached() => _readRequiredCached();
Future<EntitlementSnapshot> revalidateIfPossible() async {
try {
final snapshot = await remote.read();
await repository.save(snapshot);
return snapshot;
} on OfflineException {
return _readRequiredCached();
}
}
Future<EntitlementSnapshot> _readRequiredCached() async {
final snapshot = await repository.read();
if (snapshot == null) {
throw const OfflineException();
}
return snapshot;
}
}
final class BillingUseCases {
const BillingUseCases({
required BillingPort billingPort,
required BillingProductRef proProduct,
}) : _billingPort = billingPort,
_proProduct = proProduct;
final BillingPort _billingPort;
final BillingProductRef _proProduct;
Future<BillingAvailability> availability() {
return _billingPort.availability();
}
Future<BillingAttemptResult> purchasePro() {
return _billingPort.purchasePro(product: _proProduct);
}
Future<BillingAttemptResult> restorePurchases() {
return _billingPort.restorePurchases();
}
Future<BillingAttemptResult> revalidate() {
return _billingPort.revalidate();
}
}
enum StarterSeedStatus { inserted, skippedAlreadyApplied, skippedNotEmpty }
final class StarterSeedResult {
@ -3461,12 +3518,14 @@ final class WatchCompanionProjectionUseCases implements WatchProjectionSource {
required Clock clock,
required IdGenerator ids,
required String originDeviceId,
ActiveWorkoutSensorUseCases? activeWorkoutSensorUseCases,
WatchProjectionPublisher? publisher,
}) : _projector = WatchSessionProjectionProjector(
sessionRepository: sessionRepository,
clock: clock,
ids: ids,
originDeviceId: originDeviceId,
activeWorkoutSensorUseCases: activeWorkoutSensorUseCases,
),
_publisher = publisher;
@ -3524,6 +3583,12 @@ bool _hasSameWatchCommandRevisionState(
left.stepIndex == right.stepIndex &&
left.stepTotal == right.stepTotal &&
left.stepName == right.stepName &&
left.stepType == right.stepType &&
left.stepTargetValue == right.stepTargetValue &&
left.exerciseTargetReps == right.exerciseTargetReps &&
left.exerciseTargetTimeMs == right.exerciseTargetTimeMs &&
left.exerciseTargetScore == right.exerciseTargetScore &&
left.exerciseTargetScoreTimeMs == right.exerciseTargetScoreTimeMs &&
_hasSameWatchCommandRevisionTimerState(
left.dominantTimer,
right.dominantTimer,
@ -3543,6 +3608,7 @@ bool _hasSameWatchCommandRevisionState(
left.manualScoreTargetLabel == right.manualScoreTargetLabel &&
left.manualScoreRepsTargetValue == right.manualScoreRepsTargetValue &&
left.manualScoreScope == right.manualScoreScope &&
left.totalDistanceM == right.totalDistanceM &&
_listEquals(
left.healthServicesExerciseTypeStrategy,
right.healthServicesExerciseTypeStrategy,
@ -3684,8 +3750,9 @@ final class WatchCompanionCommandHandler implements WatchCommandIngress {
WatchCommandType.startPreparedTimedStep =>
projection.primaryAction == WatchPrimaryAction.startPreparedTimedStep,
WatchCommandType.completeCurrentStep =>
projection.stepType == WatchStepType.reps &&
projection.stepTargetValue != null,
(projection.stepType == WatchStepType.reps &&
projection.stepTargetValue != null) ||
projection.manualScoreScope == WatchManualScoreScope.step,
WatchCommandType.skipCurrentStep => projection.secondaryActions.contains(
WatchSecondaryAction.skipCurrentStep,
),
@ -3713,7 +3780,10 @@ final class WatchCompanionCommandHandler implements WatchCommandIngress {
bool _allowsStaleRevision(WatchCommandType type) {
return type == WatchCommandType.incrementScore ||
type == WatchCommandType.decrementScore;
type == WatchCommandType.decrementScore ||
type == WatchCommandType.startCurrentExercise ||
type == WatchCommandType.startPreparedTimedStep ||
type == WatchCommandType.completeCurrentStep;
}
Future<WatchCommandAck> _route(
@ -4050,16 +4120,18 @@ final class WatchSessionProjectionProjector {
required this.clock,
required this.ids,
required this.originDeviceId,
this.activeWorkoutSensorUseCases,
});
final ActiveSessionRepository sessionRepository;
final Clock clock;
final IdGenerator ids;
final String originDeviceId;
final ActiveWorkoutSensorUseCases? activeWorkoutSensorUseCases;
Future<WatchSessionProjection> project({required int revision}) async {
final now = clock.now();
final session = await sessionRepository.findOpen();
var session = await sessionRepository.findOpen();
if (session == null ||
session.status == ActiveWorkoutStatus.completed ||
session.status == ActiveWorkoutStatus.abandoned ||
@ -4078,6 +4150,24 @@ final class WatchSessionProjectionProjector {
statusLabel: 'Aucune séance en cours',
);
}
session = await _advanceExpiredRestBeforeProjection(session, now);
if (session.status == ActiveWorkoutStatus.completed ||
session.status == ActiveWorkoutStatus.abandoned ||
session.status == ActiveWorkoutStatus.savedExit) {
return WatchSessionProjection(
deviceSessionId: '',
revision: revision,
projectedAtEpochMs: _epochMs(now),
expiresAtEpochMs: _watchProjectionExpiresAtEpochMs(now),
phase: WatchSessionPhase.noActiveSession,
phoneReachable: true,
seriesIndex: 0,
seriesTotal: 0,
exerciseName: '',
primaryAction: WatchPrimaryAction.none,
statusLabel: 'Aucune séance en cours',
);
}
final snapshot = _findExerciseSnapshot(
resolvedTemplateSnapshotJson: session.resolvedTemplateSnapshotJson,
@ -4121,7 +4211,9 @@ final class WatchSessionProjectionProjector {
);
final stepView = await _readStepViewIfStarted(session, snapshot);
final stepState = stepView?.state;
final currentStep = stepView?.currentStep ?? _initialStep(snapshot);
final currentStep = stepView == null
? _initialStep(snapshot)
: stepView.currentStep;
final manualScoreProjection = _watchManualScoreProjection(
snapshot: snapshot,
currentStep: currentStep,
@ -4132,22 +4224,25 @@ final class WatchSessionProjectionProjector {
final expectedPassages = _expectedPassages(snapshot);
final projectedAtEpochMs = _epochMs(now);
final exerciseTargetTimeMs = snapshot.timeEnabled
? snapshot.targetTimeSeconds == null
? null
: snapshot.targetTimeSeconds! * 1000
: null;
final scoreStopwatchTimer = scoreStopwatch == null
? null
: _scoreStopwatchTimerProjection(scoreStopwatch, now);
final setTimerProjection = setTimer == null
? null
: _setTimerProjection(setTimer, now);
? _pendingSetTimerProjection(snapshot, now)
: _setTimerProjection(setTimer, now, targetMs: exerciseTargetTimeMs);
final allTimers = <WatchTimerProjection>[
if (activeRest != null) _restTimerProjection(activeRest, now),
if (currentStep != null && currentStep.type == ExerciseStepType.time)
_stepTimerProjection(stepState, currentStep, now),
?setTimerProjection,
?scoreStopwatchTimer,
?setTimerProjection,
];
final displayTimers = allTimers
.where((timer) => timer.kind != WatchTimerKind.setTimer)
.toList(growable: false);
final displayTimers = allTimers.toList(growable: false);
final dominantTimer = displayTimers.isEmpty ? null : displayTimers.first;
final secondaryTimers = dominantTimer == null
? const <WatchTimerProjection>[]
@ -4164,6 +4259,9 @@ final class WatchSessionProjectionProjector {
_sessionHealthServicesExerciseTypeStrategy(
session.resolvedTemplateSnapshotJson,
);
final sensorState = activeWorkoutSensorUseCases?.current(
session.metadata.id,
);
return WatchSessionProjection(
deviceSessionId: session.metadata.id,
@ -4193,6 +4291,12 @@ final class WatchSessionProjectionProjector {
null => null,
},
stepTargetValue: currentStep?.defaultTargetValue,
exerciseTargetReps: snapshot.repsEnabled ? snapshot.targetReps : null,
exerciseTargetTimeMs: exerciseTargetTimeMs,
exerciseTargetScore: snapshot.scoreEnabled ? snapshot.targetScore : null,
exerciseTargetScoreTimeMs: snapshot.scoreEnabled
? snapshot.targetScoreTimeMs
: null,
dominantTimer: dominantTimer,
secondaryTimers: secondaryTimers,
primaryAction: _primaryAction(phase),
@ -4225,6 +4329,7 @@ final class WatchSessionProjectionProjector {
manualScoreRepsTargetValue: manualScoreProjection?.repsTargetValue,
manualScoreScope: manualScoreProjection?.scope,
healthServicesExerciseTypeStrategy: healthServicesExerciseTypeStrategy,
totalDistanceM: sensorState?.latestDistanceMeters,
);
}
@ -4288,6 +4393,50 @@ final class WatchSessionProjectionProjector {
..sort((left, right) => right.startedAt.compareTo(left.startedAt));
return active.isEmpty ? null : active.first;
}
Future<ActiveWorkoutSession> _advanceExpiredRestBeforeProjection(
ActiveWorkoutSession session,
DateTime now,
) async {
final activeRest = await _findActiveRest(session.metadata.id);
if (activeRest == null ||
activeRest.pausedAt != null ||
activeRest.remainingMillisecondsAt(now) > 0) {
return session;
}
await sessionRepository.saveRestState(
activeRest.copyWith(
metadata: activeRest.metadata.touch(now),
endedAt: now,
),
);
final next = _nextPositionAfter(
session.resolvedTemplateSnapshotJson,
programIndex: activeRest.afterProgramIndex,
exerciseIndex: activeRest.afterExerciseIndex,
setIndex: activeRest.afterSetIndex,
);
final updated = next == null
? session.copyWith(
status: ActiveWorkoutStatus.completed,
endedAt: now,
lastPersistedAt: now,
elapsedActiveMs: session.elapsedActiveMillisecondsAt(now),
metadata: session.metadata.touch(now),
)
: session.copyWith(
status: ActiveWorkoutStatus.running,
currentProgramIndex: next.programIndex,
currentExerciseIndex: next.exerciseIndex,
currentSetIndex: next.setIndex,
lastPersistedAt: now,
metadata: session.metadata.touch(now),
);
await sessionRepository.save(updated);
return updated;
}
}
final class _WatchManualScoreProjectionData {
@ -4326,8 +4475,6 @@ _WatchManualScoreProjectionData? _watchManualScoreProjection({
return _WatchManualScoreProjectionData(
scope: WatchManualScoreScope.step,
value: result?.actualScore ?? 0,
targetValue: step.defaultTargetScore,
targetLabel: step.defaultTargetScore == null ? null : 'Cible',
repsTargetValue: step.type == ExerciseStepType.reps
? step.defaultTargetValue
: null,
@ -4508,7 +4655,7 @@ WatchTimerProjection? _scoreStopwatchTimerProjection(
? WatchTimerRunState.running
: WatchTimerRunState.paused,
referenceEpochMs: _epochMs(now),
accumulatedMs: state.accumulatedMs,
accumulatedMs: state.elapsedMillisecondsAt(now),
startedAtEpochMs: state.status == ActiveScoreStopwatchStatus.running
? _epochMs(state.startedAt)
: null,
@ -4517,8 +4664,9 @@ WatchTimerProjection? _scoreStopwatchTimerProjection(
WatchTimerProjection? _setTimerProjection(
ActiveSetTimerState state,
DateTime now,
) {
DateTime now, {
int? targetMs,
}) {
if (state.status == ActiveSetTimerStatus.stopped ||
state.status == ActiveSetTimerStatus.skipped) {
return null;
@ -4531,11 +4679,30 @@ WatchTimerProjection? _setTimerProjection(
? WatchTimerRunState.running
: WatchTimerRunState.paused,
referenceEpochMs: _epochMs(now),
accumulatedMs: state.accumulatedMs,
accumulatedMs: state.elapsedMillisecondsAt(now),
startedAtEpochMs:
state.status == ActiveSetTimerStatus.running && state.startedAt != null
? _epochMs(state.startedAt!)
: null,
targetMs: targetMs,
);
}
WatchTimerProjection? _pendingSetTimerProjection(
_ResolvedExerciseSnapshot snapshot,
DateTime now,
) {
if (!snapshot.timeEnabled || snapshot.targetTimeSeconds == null) {
return null;
}
return WatchTimerProjection(
kind: WatchTimerKind.setTimer,
label: 'Temps de série',
displayMode: WatchTimerDisplayMode.elapsed,
runState: WatchTimerRunState.stopped,
referenceEpochMs: _epochMs(now),
accumulatedMs: 0,
targetMs: snapshot.targetTimeSeconds! * 1000,
);
}
@ -5457,6 +5624,8 @@ final class CloseWorkoutSessionUseCase {
required this.sessionRepository,
required this.historyRepository,
this.telemetryRepository,
this.healthConnectUseCases,
this.activeWorkoutSensorUseCases,
required this.clock,
required this.ids,
required this.originDeviceId,
@ -5465,6 +5634,8 @@ final class CloseWorkoutSessionUseCase {
final ActiveSessionRepository sessionRepository;
final WorkoutHistoryRepository historyRepository;
final WorkoutTelemetryRepository? telemetryRepository;
final HealthConnectUseCases? healthConnectUseCases;
final ActiveWorkoutSensorUseCases? activeWorkoutSensorUseCases;
final Clock clock;
final IdGenerator ids;
final String originDeviceId;
@ -5510,6 +5681,11 @@ final class CloseWorkoutSessionUseCase {
final telemetrySamples =
await telemetryRepository?.listSamples(session.metadata.id) ??
const <WorkoutTelemetrySample>[];
final totalSteps =
_totalStepsFromSamples(telemetrySamples) ??
activeWorkoutSensorUseCases
?.current(session.metadata.id)
?.latestStepCount;
final history = WorkoutHistory(
metadata: EntityMetadata(
id: historyId,
@ -5582,16 +5758,19 @@ final class CloseWorkoutSessionUseCase {
'telemetrySamples': telemetrySamples
.map(_workoutTelemetrySampleSnapshotJson)
.toList(),
'totalSteps': totalSteps,
}),
minHeartRateBpm: telemetryAggregate?.minHeartRateBpm,
averageHeartRateBpm: telemetryAggregate?.averageHeartRateBpm,
maxHeartRateBpm: telemetryAggregate?.maxHeartRateBpm,
totalDistanceMeters: telemetryAggregate?.totalDistanceMeters,
totalCaloriesKcal: telemetryAggregate?.totalCaloriesKcal,
totalSteps: totalSteps,
results: historyResults,
stepResults: historyStepResults,
);
await historyRepository.save(history);
await healthConnectUseCases?.exportAfterWorkout(history);
return history;
}
}
@ -5822,6 +6001,7 @@ final class WorkoutTelemetryUseCases {
heartRateBpm: state.heartRateBpm,
distanceMeters: state.distanceMeters,
caloriesKcal: state.caloriesKcal,
stepCount: state.stepCount,
);
}
@ -5859,6 +6039,9 @@ final class WorkoutTelemetryUseCases {
heartRateBpm: hasHeartRate ? sample.heartRateBpm : null,
distanceMeters: hasDistance ? sample.distanceMeters : null,
caloriesKcal: hasCalories ? sample.caloriesKcal : null,
stepCount: sample.stepCount != null && sample.stepCount! >= 0
? sample.stepCount
: null,
);
}
@ -6135,6 +6318,7 @@ Map<String, Object?> _workoutTelemetrySampleSnapshotJson(
'heartRateBpm': sample.heartRateBpm,
'distanceMeters': sample.distanceMeters,
'caloriesKcal': sample.caloriesKcal,
'stepCount': sample.stepCount,
};
}
@ -6177,12 +6361,26 @@ List<WorkoutTelemetrySample> _telemetrySamplesFromHistorySnapshot(
heartRateBpm: json['heartRateBpm'] as int?,
distanceMeters: (json['distanceMeters'] as num?)?.toDouble(),
caloriesKcal: (json['caloriesKcal'] as num?)?.toDouble(),
stepCount: (json['stepCount'] as num?)?.toInt(),
),
);
}
return output;
}
int? _totalStepsFromSamples(List<WorkoutTelemetrySample> samples) {
int? totalSteps;
for (final sample in samples) {
final stepCount = sample.stepCount;
if (stepCount != null &&
stepCount >= 0 &&
(totalSteps == null || stepCount > totalSteps)) {
totalSteps = stepCount;
}
}
return totalSteps;
}
bool _matchesTelemetryScope(
WorkoutTelemetrySample sample, {
required WorkoutTelemetryAggregateScope scope,
@ -6390,6 +6588,131 @@ final class _TelemetryAggregateBuilder {
}
}
final class HealthConnectUseCases {
const HealthConnectUseCases({
required this.gateway,
required this.historyRepository,
this.telemetryUseCases,
});
final HealthConnectGateway gateway;
final WorkoutHistoryRepository historyRepository;
final WorkoutTelemetryUseCases? telemetryUseCases;
Future<HealthConnectConnectionState> connectionState() {
return gateway.connectionState();
}
Future<HealthConnectConnectionState> requestPermissions() {
return gateway.requestPermissions();
}
Future<bool> openSettings() {
return gateway.openSettings();
}
Future<HealthConnectWorkoutExportResult> exportHistory(
String historyId,
) async {
final history = await historyRepository.findById(historyId);
if (history == null) {
return const HealthConnectWorkoutExportResult(
status: HealthConnectExportStatus.invalidWorkout,
workout: null,
errorMessage: 'Workout history not found.',
);
}
return exportAfterWorkout(history);
}
Future<HealthConnectWorkoutExportResult> exportAfterWorkout(
WorkoutHistory history,
) async {
final workout = await _workoutExportFromHistory(history);
if (!workout.isValid) {
return HealthConnectWorkoutExportResult(
status: HealthConnectExportStatus.invalidWorkout,
workout: workout,
);
}
try {
final state = await gateway.connectionState();
switch (state.status) {
case HealthConnectConnectionStatus.unavailable:
return HealthConnectWorkoutExportResult(
status: HealthConnectExportStatus.unavailable,
workout: workout,
);
case HealthConnectConnectionStatus.providerUpdateRequired:
return HealthConnectWorkoutExportResult(
status: HealthConnectExportStatus.providerUpdateRequired,
workout: workout,
);
case HealthConnectConnectionStatus.accessBlocked:
return HealthConnectWorkoutExportResult(
status: HealthConnectExportStatus.accessBlocked,
workout: workout,
);
case HealthConnectConnectionStatus.permissionsRequired:
return HealthConnectWorkoutExportResult(
status: HealthConnectExportStatus.permissionsRequired,
workout: workout,
);
case HealthConnectConnectionStatus.connected:
await gateway.exportWorkout(workout);
return HealthConnectWorkoutExportResult(
status: HealthConnectExportStatus.exported,
workout: workout,
);
}
} on Object catch (error) {
return HealthConnectWorkoutExportResult(
status: HealthConnectExportStatus.failed,
workout: workout,
errorMessage: error.toString(),
);
}
}
Future<HealthConnectWorkoutExport> _workoutExportFromHistory(
WorkoutHistory history,
) async {
final samples =
await telemetryUseCases?.listSamplesForHistory(history) ??
const <WorkoutTelemetrySample>[];
return HealthConnectWorkoutExport(
historyId: history.metadata.id,
title: history.nameSnapshot,
startedAt: history.startedAt,
endedAt: history.endedAt,
durationMs: history.totalActiveMs,
totalDistanceMeters: _positiveDoubleOrNull(history.totalDistanceMeters),
totalCaloriesKcal: _positiveDoubleOrNull(history.totalCaloriesKcal),
minHeartRateBpm: history.minHeartRateBpm,
averageHeartRateBpm: history.averageHeartRateBpm,
maxHeartRateBpm: history.maxHeartRateBpm,
heartRateSamples: [
for (final sample in samples)
if (sample.heartRateBpm != null &&
!sample.capturedAt.isBefore(history.startedAt) &&
!sample.capturedAt.isAfter(history.endedAt))
HealthConnectHeartRateSample(
time: sample.capturedAt,
beatsPerMinute: sample.heartRateBpm!,
),
],
);
}
}
double? _positiveDoubleOrNull(double? value) {
if (value == null || value <= 0) {
return null;
}
return value;
}
final class ActiveWorkoutSensorState {
const ActiveWorkoutSensorState({
required this.sessionId,
@ -6403,6 +6726,7 @@ final class ActiveWorkoutSensorState {
this.latestDistanceMeters,
required this.latestDistanceAvailable,
this.latestCaloriesKcal,
this.latestStepCount,
required this.estimatedCaloriesKcal,
});
@ -6417,6 +6741,7 @@ final class ActiveWorkoutSensorState {
final double? latestDistanceMeters;
final bool latestDistanceAvailable;
final double? latestCaloriesKcal;
final int? latestStepCount;
final double estimatedCaloriesKcal;
}
@ -6445,7 +6770,9 @@ final class ActiveWorkoutSensorUseCases {
sample.distanceMeters != null && sample.distanceMeters! >= 0;
final hasCalories =
sample.caloriesKcal != null && sample.caloriesKcal! >= 0;
if (sessionId.isEmpty || (!hasHeartRate && !hasDistance && !hasCalories)) {
final hasSteps = sample.stepCount != null && sample.stepCount! >= 0;
if (sessionId.isEmpty ||
(!hasHeartRate && !hasDistance && !hasCalories && !hasSteps)) {
return null;
}
final recordedAt = sample.capturedAtEpochMs > 0
@ -6463,6 +6790,7 @@ final class ActiveWorkoutSensorUseCases {
heartRateBpm: hasHeartRate ? sample.heartRateBpm : null,
distanceMeters: hasDistance ? sample.distanceMeters : null,
caloriesKcal: hasCalories ? sample.caloriesKcal : null,
stepCount: hasSteps ? sample.stepCount : null,
recordedAt: recordedAt,
);
if (snapshot == null) {
@ -6497,6 +6825,7 @@ final class _ActiveWorkoutSensorAccumulator {
double? _latestDistanceMeters;
var _latestDistanceAvailable = false;
double? _latestCaloriesKcal;
int? _latestStepCount;
ActiveWorkoutSensorState get snapshot {
final averageHeartRateBpm = _heartRateSampleCount == 0
@ -6514,6 +6843,7 @@ final class _ActiveWorkoutSensorAccumulator {
latestDistanceMeters: _latestDistanceMeters,
latestDistanceAvailable: _latestDistanceAvailable,
latestCaloriesKcal: _latestCaloriesKcal,
latestStepCount: _latestStepCount,
estimatedCaloriesKcal: _estimatedCaloriesKcal(
averageHeartRateBpm: averageHeartRateBpm ?? 0,
activeDuration: _latestSampleAt.difference(firstSampleAt),
@ -6526,6 +6856,7 @@ final class _ActiveWorkoutSensorAccumulator {
required int? heartRateBpm,
required double? distanceMeters,
required double? caloriesKcal,
required int? stepCount,
required DateTime recordedAt,
}) {
final stableSampleId = sampleId?.trim();
@ -6564,6 +6895,10 @@ final class _ActiveWorkoutSensorAccumulator {
(_latestCaloriesKcal == null || caloriesKcal >= _latestCaloriesKcal!)) {
_latestCaloriesKcal = caloriesKcal;
}
if (stepCount != null &&
(_latestStepCount == null || stepCount >= _latestStepCount!)) {
_latestStepCount = stepCount;
}
return snapshot;
}
}