feat(watch): Wear OS companion app - UX surfaces + bridge client (#91-E, #91-F)
This commit is contained in:
285
watch_app/lib/application/watch_session_view_model.dart
Normal file
285
watch_app/lib/application/watch_session_view_model.dart
Normal file
@ -0,0 +1,285 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
import 'package:watch_bridge_contract/watch_bridge_contract.dart';
|
||||
|
||||
import '../infrastructure/watch_bridge/native_watch_bridge_client.dart';
|
||||
|
||||
final class WatchSessionUiState {
|
||||
const WatchSessionUiState({
|
||||
required this.projection,
|
||||
this.commandPending = false,
|
||||
this.waitingForPhone = false,
|
||||
this.connectionLost = false,
|
||||
this.staleProjection = false,
|
||||
this.lastAck,
|
||||
});
|
||||
|
||||
final WatchSessionProjection projection;
|
||||
final bool commandPending;
|
||||
final bool waitingForPhone;
|
||||
final bool connectionLost;
|
||||
final bool staleProjection;
|
||||
final WatchCommandAckEvent? lastAck;
|
||||
|
||||
bool get actionsEnabled => !commandPending && !connectionLost;
|
||||
|
||||
WatchSessionUiState copyWith({
|
||||
WatchSessionProjection? projection,
|
||||
bool? commandPending,
|
||||
bool? waitingForPhone,
|
||||
bool? connectionLost,
|
||||
bool? staleProjection,
|
||||
WatchCommandAckEvent? lastAck,
|
||||
}) {
|
||||
return WatchSessionUiState(
|
||||
projection: projection ?? this.projection,
|
||||
commandPending: commandPending ?? this.commandPending,
|
||||
waitingForPhone: waitingForPhone ?? this.waitingForPhone,
|
||||
connectionLost: connectionLost ?? this.connectionLost,
|
||||
staleProjection: staleProjection ?? this.staleProjection,
|
||||
lastAck: lastAck ?? this.lastAck,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
final class WatchSessionViewModel extends ValueNotifier<WatchSessionUiState> {
|
||||
WatchSessionViewModel({
|
||||
NativeWatchBridgeClient nativeClient =
|
||||
const MethodChannelNativeWatchBridgeClient(),
|
||||
Duration waitingThreshold = const Duration(milliseconds: 500),
|
||||
Duration commandTimeout = const Duration(seconds: 2),
|
||||
Duration staleProjectionThreshold = const Duration(seconds: 6),
|
||||
Duration connectionLostThreshold = const Duration(seconds: 10),
|
||||
}) : _nativeClient = nativeClient,
|
||||
_waitingThreshold = waitingThreshold,
|
||||
_commandTimeout = commandTimeout,
|
||||
_staleProjectionThreshold = staleProjectionThreshold,
|
||||
_connectionLostThreshold = connectionLostThreshold,
|
||||
super(WatchSessionUiState(projection: _initialProjection())) {
|
||||
_subscriptions.add(_nativeClient.projections.listen(_handleProjection));
|
||||
_subscriptions.add(_nativeClient.acks.listen(_handleAck));
|
||||
_subscriptions.add(
|
||||
_nativeClient.connectionEvents.listen(_handleConnectionEvent),
|
||||
);
|
||||
unawaited(_nativeClient.requestCapabilityRefresh());
|
||||
unawaited(_nativeClient.requestResync());
|
||||
_freshnessTimer = Timer.periodic(const Duration(seconds: 1), (_) {
|
||||
_syncFreshnessState();
|
||||
});
|
||||
}
|
||||
|
||||
final NativeWatchBridgeClient _nativeClient;
|
||||
final Duration _waitingThreshold;
|
||||
final Duration _commandTimeout;
|
||||
final Duration _staleProjectionThreshold;
|
||||
final Duration _connectionLostThreshold;
|
||||
final _subscriptions = <StreamSubscription<dynamic>>[];
|
||||
|
||||
Timer? _waitingTimer;
|
||||
Timer? _commandTimeoutTimer;
|
||||
Timer? _freshnessTimer;
|
||||
WatchCommandEnvelope? _pendingCommand;
|
||||
DateTime? _lastProjectionReceivedAt;
|
||||
var _commandCounter = 0;
|
||||
|
||||
Future<void> refresh() async {
|
||||
value = value.copyWith(connectionLost: false);
|
||||
try {
|
||||
await _nativeClient.requestCapabilityRefresh();
|
||||
await _nativeClient.requestResync();
|
||||
} on PlatformException {
|
||||
value = value.copyWith(connectionLost: true);
|
||||
unawaited(HapticFeedback.heavyImpact());
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> sendPrimaryAction() async {
|
||||
final action = value.projection.primaryAction;
|
||||
final command = switch (action) {
|
||||
WatchPrimaryAction.none => null,
|
||||
WatchPrimaryAction.startCurrentExercise =>
|
||||
WatchCommandType.startCurrentExercise,
|
||||
WatchPrimaryAction.pauseSession => WatchCommandType.pauseSession,
|
||||
WatchPrimaryAction.resumeSession => WatchCommandType.resumeSession,
|
||||
WatchPrimaryAction.startPreparedTimedStep =>
|
||||
WatchCommandType.startPreparedTimedStep,
|
||||
WatchPrimaryAction.skipCurrentRest => WatchCommandType.skipCurrentRest,
|
||||
};
|
||||
if (command == null) {
|
||||
await refresh();
|
||||
return;
|
||||
}
|
||||
await _sendCommand(command);
|
||||
}
|
||||
|
||||
Future<void> sendSecondaryAction(WatchSecondaryAction action) {
|
||||
final command = switch (action) {
|
||||
WatchSecondaryAction.skipCurrentStep => WatchCommandType.skipCurrentStep,
|
||||
WatchSecondaryAction.skipCurrentPassage =>
|
||||
WatchCommandType.skipCurrentPassage,
|
||||
WatchSecondaryAction.finishCurrentSet => WatchCommandType.finishCurrentSet,
|
||||
WatchSecondaryAction.skipCurrentSet => WatchCommandType.skipCurrentSet,
|
||||
WatchSecondaryAction.skipCurrentRest => WatchCommandType.skipCurrentRest,
|
||||
};
|
||||
return _sendCommand(command);
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
_waitingTimer?.cancel();
|
||||
_commandTimeoutTimer?.cancel();
|
||||
_freshnessTimer?.cancel();
|
||||
for (final subscription in _subscriptions) {
|
||||
unawaited(subscription.cancel());
|
||||
}
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
Future<void> _sendCommand(WatchCommandType type) async {
|
||||
if (!value.actionsEnabled || value.projection.deviceSessionId.isEmpty) {
|
||||
return;
|
||||
}
|
||||
final nowMs = DateTime.now().toUtc().millisecondsSinceEpoch;
|
||||
final command = WatchCommandEnvelope(
|
||||
commandId: 'watch-$nowMs-${_commandCounter++}',
|
||||
type: type,
|
||||
sessionId: value.projection.deviceSessionId,
|
||||
expectedRevision: value.projection.revision,
|
||||
sentAtEpochMs: nowMs,
|
||||
);
|
||||
_pendingCommand = command;
|
||||
value = value.copyWith(
|
||||
commandPending: true,
|
||||
waitingForPhone: false,
|
||||
connectionLost: false,
|
||||
);
|
||||
_waitingTimer?.cancel();
|
||||
_commandTimeoutTimer?.cancel();
|
||||
_waitingTimer = Timer(_waitingThreshold, () {
|
||||
value = value.copyWith(waitingForPhone: true);
|
||||
});
|
||||
_commandTimeoutTimer = Timer(_commandTimeout, () {
|
||||
_pendingCommand = null;
|
||||
value = value.copyWith(
|
||||
commandPending: false,
|
||||
waitingForPhone: false,
|
||||
connectionLost: true,
|
||||
);
|
||||
unawaited(HapticFeedback.heavyImpact());
|
||||
});
|
||||
try {
|
||||
await _nativeClient.sendCommand(command);
|
||||
} on PlatformException {
|
||||
_pendingCommand = null;
|
||||
_clearCommandTimers();
|
||||
value = value.copyWith(
|
||||
commandPending: false,
|
||||
waitingForPhone: false,
|
||||
connectionLost: true,
|
||||
);
|
||||
unawaited(HapticFeedback.heavyImpact());
|
||||
}
|
||||
}
|
||||
|
||||
void _handleProjection(WatchSessionProjection projection) {
|
||||
final previousProjection = value.projection;
|
||||
_lastProjectionReceivedAt = DateTime.now();
|
||||
_pendingCommand = null;
|
||||
_clearCommandTimers();
|
||||
value = WatchSessionUiState(
|
||||
projection: projection,
|
||||
lastAck: value.lastAck,
|
||||
);
|
||||
_triggerProjectionHaptic(previousProjection, projection);
|
||||
}
|
||||
|
||||
void _handleAck(WatchCommandAckEvent ack) {
|
||||
if (_pendingCommand?.commandId != ack.commandId) {
|
||||
value = value.copyWith(lastAck: ack);
|
||||
return;
|
||||
}
|
||||
_waitingTimer?.cancel();
|
||||
value = value.copyWith(
|
||||
waitingForPhone: false,
|
||||
connectionLost: false,
|
||||
lastAck: ack,
|
||||
);
|
||||
unawaited(HapticFeedback.lightImpact());
|
||||
if (_isRejected(ack.status)) {
|
||||
_pendingCommand = null;
|
||||
_clearCommandTimers();
|
||||
value = value.copyWith(commandPending: false);
|
||||
unawaited(_nativeClient.requestResync());
|
||||
}
|
||||
}
|
||||
|
||||
void _handleConnectionEvent(WatchBridgeConnectionEvent event) {
|
||||
value = value.copyWith(connectionLost: !event.isReachable);
|
||||
if (event.isReachable || event.requestsResync) {
|
||||
unawaited(_nativeClient.requestResync());
|
||||
}
|
||||
}
|
||||
|
||||
void _syncFreshnessState() {
|
||||
final receivedAt = _lastProjectionReceivedAt;
|
||||
if (receivedAt == null) {
|
||||
return;
|
||||
}
|
||||
final age = DateTime.now().difference(receivedAt);
|
||||
final stale = age >= _staleProjectionThreshold;
|
||||
final lost = age >= _connectionLostThreshold;
|
||||
if (stale != value.staleProjection || lost != value.connectionLost) {
|
||||
value = value.copyWith(staleProjection: stale, connectionLost: lost);
|
||||
}
|
||||
}
|
||||
|
||||
void _clearCommandTimers() {
|
||||
_waitingTimer?.cancel();
|
||||
_waitingTimer = null;
|
||||
_commandTimeoutTimer?.cancel();
|
||||
_commandTimeoutTimer = null;
|
||||
}
|
||||
|
||||
void _triggerProjectionHaptic(
|
||||
WatchSessionProjection previous,
|
||||
WatchSessionProjection current,
|
||||
) {
|
||||
final phaseChanged = previous.phase != current.phase;
|
||||
final enteredReadyTimer = current.phase == WatchSessionPhase.nextTimerReady &&
|
||||
previous.phase != WatchSessionPhase.nextTimerReady;
|
||||
final enteredRestEnd =
|
||||
previous.phase == WatchSessionPhase.restRunning &&
|
||||
current.phase != WatchSessionPhase.restRunning &&
|
||||
current.phase != WatchSessionPhase.restPaused;
|
||||
if (phaseChanged && (enteredReadyTimer || enteredRestEnd)) {
|
||||
unawaited(HapticFeedback.mediumImpact());
|
||||
unawaited(Future<void>.delayed(const Duration(milliseconds: 120), () {
|
||||
return HapticFeedback.mediumImpact();
|
||||
}));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool _isRejected(WatchCommandAck ack) {
|
||||
return switch (ack) {
|
||||
WatchCommandAck.accepted || WatchCommandAck.acceptedNoOp => false,
|
||||
_ => true,
|
||||
};
|
||||
}
|
||||
|
||||
WatchSessionProjection _initialProjection() {
|
||||
return WatchSessionProjection(
|
||||
deviceSessionId: '',
|
||||
revision: 0,
|
||||
projectedAtEpochMs: DateTime.now().toUtc().millisecondsSinceEpoch,
|
||||
phase: WatchSessionPhase.noActiveSession,
|
||||
phoneReachable: false,
|
||||
seriesIndex: 0,
|
||||
seriesTotal: 0,
|
||||
exerciseName: '',
|
||||
primaryAction: WatchPrimaryAction.none,
|
||||
statusLabel: 'Téléphone indisponible',
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user