141 lines
4.5 KiB
Dart
141 lines
4.5 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
|
|
import '../../transport/link_transport.dart';
|
|
import '../../transport/udp/udp_transport.dart';
|
|
import 'database_provider.dart';
|
|
|
|
/// App-lebenslanger UDP-Transport (Doku Kommunikationsschicht Abschnitt 3),
|
|
/// verdrahtet gegen Host/Port aus den Einstellungen. Analog zu
|
|
/// [bluetoothTransportProvider] bewusst nicht autoDispose - siehe dortige
|
|
/// Begruendung.
|
|
final wifiTransportProvider = Provider<UdpTransport>((ref) {
|
|
final settingsRepo = ref.watch(appSettingsRepositoryProvider);
|
|
final transport = UdpTransport(
|
|
getHost: settingsRepo.loadConnectionWifiHost,
|
|
getPort: settingsRepo.loadConnectionWifiPort,
|
|
);
|
|
ref.onDispose(transport.dispose);
|
|
return transport;
|
|
});
|
|
|
|
/// Reaktiver [LinkState] des WLAN-Transports fuer die Oberflaeche.
|
|
final wifiLinkStateProvider = StreamProvider<LinkState>((ref) {
|
|
final transport = ref.watch(wifiTransportProvider);
|
|
return transport.state;
|
|
});
|
|
|
|
/// Grund des zuletzt gemeldeten [LinkState.error] des WLAN-Transports.
|
|
final wifiLinkErrorReasonProvider = Provider<LinkErrorReason?>((ref) {
|
|
ref.watch(wifiLinkStateProvider);
|
|
return ref.watch(wifiTransportProvider).lastErrorReason;
|
|
});
|
|
|
|
/// Zeigt an, ob gerade UDP-Pakete ankommen ("receiving"/"not receiving"),
|
|
/// unabhaengig vom (binaeren) Verbindungszustand - der Socket kann offen
|
|
/// sein (LinkState.connected), ohne dass die Gegenstelle tatsaechlich
|
|
/// sendet. Faellt [_receivingTimeout] nach dem letzten Paket automatisch
|
|
/// wieder auf "not receiving" zurueck, dafuer muss ein Timer laufen statt
|
|
/// nur auf den incoming-Stream zu reagieren.
|
|
class WifiStreamActivityNotifier extends Notifier<bool> {
|
|
static const _receivingTimeout = Duration(seconds: 2);
|
|
|
|
StreamSubscription<void>? _dataSub;
|
|
StreamSubscription<LinkState>? _stateSub;
|
|
Timer? _timeoutTimer;
|
|
|
|
@override
|
|
bool build() {
|
|
final transport = ref.watch(wifiTransportProvider);
|
|
_dataSub?.cancel();
|
|
_stateSub?.cancel();
|
|
_timeoutTimer?.cancel();
|
|
_dataSub = transport.incoming.listen((_) => _onPacket());
|
|
_stateSub = transport.state.listen(_onStateChanged);
|
|
ref.onDispose(() {
|
|
_dataSub?.cancel();
|
|
_stateSub?.cancel();
|
|
_timeoutTimer?.cancel();
|
|
});
|
|
return false;
|
|
}
|
|
|
|
void _onPacket() {
|
|
state = true;
|
|
_timeoutTimer?.cancel();
|
|
_timeoutTimer = Timer(_receivingTimeout, () => state = false);
|
|
}
|
|
|
|
void _onStateChanged(LinkState linkState) {
|
|
if (linkState != LinkState.connected) {
|
|
_timeoutTimer?.cancel();
|
|
state = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
final wifiStreamActivityProvider =
|
|
NotifierProvider<WifiStreamActivityNotifier, bool>(
|
|
WifiStreamActivityNotifier.new);
|
|
|
|
/// Ein Eintrag im WLAN-Verbindungsprotokoll (Doku 7).
|
|
class WifiConnectionLogEntry {
|
|
const WifiConnectionLogEntry(this.timestamp, this.message);
|
|
|
|
final DateTime timestamp;
|
|
final String message;
|
|
}
|
|
|
|
/// Verbindungsprotokoll + Paketzaehler fuer den WLAN-Transport, analog zu
|
|
/// [ConnectionLogNotifier] fuer Bluetooth.
|
|
class WifiConnectionLogNotifier
|
|
extends Notifier<List<WifiConnectionLogEntry>> {
|
|
static const _maxEntries = 50;
|
|
|
|
StreamSubscription<LinkState>? _stateSub;
|
|
StreamSubscription<void>? _dataSub;
|
|
int _packetCount = 0;
|
|
|
|
int get packetCount => _packetCount;
|
|
|
|
@override
|
|
List<WifiConnectionLogEntry> build() {
|
|
final transport = ref.watch(wifiTransportProvider);
|
|
_stateSub?.cancel();
|
|
_dataSub?.cancel();
|
|
_packetCount = 0;
|
|
_stateSub = transport.state.listen(_onStateChanged);
|
|
_dataSub = transport.incoming.listen((_) => _packetCount++);
|
|
ref.onDispose(() {
|
|
_stateSub?.cancel();
|
|
_dataSub?.cancel();
|
|
});
|
|
return const [];
|
|
}
|
|
|
|
void _onStateChanged(LinkState linkState) {
|
|
final transport = ref.read(wifiTransportProvider);
|
|
final message = switch (linkState) {
|
|
LinkState.disconnected => 'Disconnected',
|
|
LinkState.connecting => 'Connecting...',
|
|
LinkState.connected => 'Listening on port ${transport.boundPort}',
|
|
LinkState.error => 'Error: '
|
|
'${transport.lastErrorMessage ?? transport.lastErrorReason?.name ?? 'unknown'}',
|
|
};
|
|
_append(message);
|
|
}
|
|
|
|
void _append(String message) {
|
|
final entry = WifiConnectionLogEntry(DateTime.now(), message);
|
|
final next = [...state, entry];
|
|
state = next.length > _maxEntries
|
|
? next.sublist(next.length - _maxEntries)
|
|
: next;
|
|
}
|
|
}
|
|
|
|
final wifiConnectionLogProvider =
|
|
NotifierProvider<WifiConnectionLogNotifier, List<WifiConnectionLogEntry>>(
|
|
WifiConnectionLogNotifier.new);
|