467 lines
13 KiB
Dart
467 lines
13 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:abawo_bt_app/model/shifter_types.dart';
|
|
import 'package:abawo_bt_app/service/shifter_service.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
class BikeScanDialog extends StatefulWidget {
|
|
const BikeScanDialog({
|
|
required this.shifter,
|
|
super.key,
|
|
});
|
|
|
|
final ShifterService shifter;
|
|
|
|
static Future<TrainerScanResult?> show(
|
|
BuildContext context, {
|
|
required ShifterService shifter,
|
|
}) {
|
|
return showDialog<TrainerScanResult>(
|
|
context: context,
|
|
barrierDismissible: true,
|
|
builder: (_) => BikeScanDialog(shifter: shifter),
|
|
);
|
|
}
|
|
|
|
@override
|
|
State<BikeScanDialog> createState() => _BikeScanDialogState();
|
|
}
|
|
|
|
class _BikeScanDialogState extends State<BikeScanDialog> {
|
|
bool _showOnlyFtms = true;
|
|
bool _isStartingScan = true;
|
|
bool _isScanning = false;
|
|
String? _scanError;
|
|
final Map<String, TrainerScanResult> _resultsByAddress = {};
|
|
StreamSubscription<TrainerScanEvent>? _scanSubscription;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
unawaited(_startScan());
|
|
}
|
|
|
|
Future<void> _startScan() async {
|
|
await _scanSubscription?.cancel();
|
|
if (_isScanning) {
|
|
await widget.shifter.stopTrainerScan();
|
|
}
|
|
|
|
setState(() {
|
|
_isStartingScan = true;
|
|
_isScanning = false;
|
|
_scanError = null;
|
|
_resultsByAddress.clear();
|
|
});
|
|
|
|
try {
|
|
_scanSubscription = widget.shifter.subscribeToTrainerScanResults().listen(
|
|
_handleScanEvent,
|
|
onError: (Object error) {
|
|
if (!mounted) {
|
|
return;
|
|
}
|
|
setState(() {
|
|
_scanError = error.toString();
|
|
_isStartingScan = false;
|
|
_isScanning = false;
|
|
});
|
|
},
|
|
);
|
|
|
|
final startResult = await widget.shifter.startTrainerScan();
|
|
if (startResult.isErr()) {
|
|
_scanError = startResult.unwrapErr().toString();
|
|
} else {
|
|
_isScanning = true;
|
|
}
|
|
} catch (error) {
|
|
_scanError = error.toString();
|
|
} finally {
|
|
if (mounted) {
|
|
setState(() {
|
|
_isStartingScan = false;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
void _handleScanEvent(TrainerScanEvent event) {
|
|
if (!mounted) {
|
|
return;
|
|
}
|
|
|
|
setState(() {
|
|
_isStartingScan = false;
|
|
switch (event.kind) {
|
|
case TrainerScanEventKind.scanStarted:
|
|
_isScanning = true;
|
|
_scanError = null;
|
|
break;
|
|
case TrainerScanEventKind.device:
|
|
final result = event.result;
|
|
if (result != null) {
|
|
_resultsByAddress[result.address.key] = result;
|
|
}
|
|
break;
|
|
case TrainerScanEventKind.scanFinished:
|
|
case TrainerScanEventKind.scanCancelled:
|
|
_isScanning = false;
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_scanSubscription?.cancel();
|
|
if (_isScanning) {
|
|
unawaited(widget.shifter.stopTrainerScan());
|
|
}
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final size = MediaQuery.of(context).size;
|
|
final dialogWidth = size.width < 640 ? size.width - 24 : 560.0;
|
|
final dialogHeight = size.height < 780 ? size.height * 0.78 : 560.0;
|
|
|
|
return Dialog(
|
|
clipBehavior: Clip.antiAlias,
|
|
insetPadding: const EdgeInsets.symmetric(horizontal: 12, vertical: 24),
|
|
shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(28)),
|
|
child: SizedBox(
|
|
width: dialogWidth,
|
|
height: dialogHeight,
|
|
child: Column(
|
|
children: [
|
|
_DialogHeader(
|
|
showOnlyFtms: _showOnlyFtms,
|
|
isScanning: _isStartingScan || _isScanning,
|
|
onChanged: (value) {
|
|
setState(() {
|
|
_showOnlyFtms = value;
|
|
});
|
|
},
|
|
onRescan: _startScan,
|
|
),
|
|
Expanded(child: _buildBody(context)),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildBody(BuildContext context) {
|
|
if (_scanError != null) {
|
|
return _ScanMessage(
|
|
message: 'Could not start shifter trainer scan: $_scanError',
|
|
action: TextButton.icon(
|
|
onPressed: _startScan,
|
|
icon: const Icon(Icons.refresh),
|
|
label: const Text('Retry'),
|
|
),
|
|
);
|
|
}
|
|
|
|
if (_isStartingScan && _resultsByAddress.isEmpty) {
|
|
return const Center(child: CircularProgressIndicator());
|
|
}
|
|
|
|
final devices = _filteredDevices();
|
|
if (devices.isEmpty) {
|
|
return _ScanMessage(
|
|
message: _isScanning
|
|
? 'The shifter is scanning. Nearby trainers will appear here as soon as the shifter reports them.'
|
|
: 'No matching trainers were reported by the shifter. Rescan with the trainer nearby and awake.',
|
|
);
|
|
}
|
|
|
|
return ListView.separated(
|
|
padding: const EdgeInsets.fromLTRB(20, 0, 20, 20),
|
|
itemCount: devices.length,
|
|
separatorBuilder: (_, __) => const SizedBox(height: 12),
|
|
itemBuilder: (context, index) => _TrainerScanResultTile(
|
|
result: devices[index],
|
|
onTap: () => Navigator.of(context).pop(devices[index]),
|
|
),
|
|
);
|
|
}
|
|
|
|
List<TrainerScanResult> _filteredDevices() {
|
|
final devices = _resultsByAddress.values.where((device) {
|
|
return !_showOnlyFtms || device.ftmsDetected;
|
|
}).toList(growable: false);
|
|
devices.sort((a, b) {
|
|
final ftmsCompare = (b.ftmsDetected ? 1 : 0) - (a.ftmsDetected ? 1 : 0);
|
|
if (ftmsCompare != 0) {
|
|
return ftmsCompare;
|
|
}
|
|
return b.rssi.compareTo(a.rssi);
|
|
});
|
|
return devices;
|
|
}
|
|
}
|
|
|
|
class _DialogHeader extends StatelessWidget {
|
|
const _DialogHeader({
|
|
required this.showOnlyFtms,
|
|
required this.isScanning,
|
|
required this.onChanged,
|
|
required this.onRescan,
|
|
});
|
|
|
|
final bool showOnlyFtms;
|
|
final bool isScanning;
|
|
final ValueChanged<bool> onChanged;
|
|
final VoidCallback onRescan;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Padding(
|
|
padding: const EdgeInsets.fromLTRB(20, 20, 20, 16),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
'Assign Trainer',
|
|
style:
|
|
Theme.of(context).textTheme.headlineSmall?.copyWith(
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
const SizedBox(height: 6),
|
|
Text(
|
|
'The shifter scans nearby trainers. Tap one to assign it.',
|
|
style: Theme.of(context).textTheme.bodyMedium?.copyWith(
|
|
color: Theme.of(context)
|
|
.colorScheme
|
|
.onSurface
|
|
.withValues(alpha: 0.68),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
IconButton(
|
|
tooltip: 'Close',
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
icon: const Icon(Icons.close),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 16),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: Row(
|
|
children: [
|
|
Text(
|
|
'FTMS only',
|
|
style: Theme.of(context).textTheme.bodyMedium?.copyWith(
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Switch(value: showOnlyFtms, onChanged: onChanged),
|
|
],
|
|
),
|
|
),
|
|
SizedBox(
|
|
width: 132,
|
|
child: OutlinedButton.icon(
|
|
style: OutlinedButton.styleFrom(
|
|
minimumSize: const Size(0, 48),
|
|
),
|
|
onPressed: isScanning ? null : onRescan,
|
|
icon: isScanning
|
|
? const SizedBox(
|
|
width: 16,
|
|
height: 16,
|
|
child: CircularProgressIndicator(strokeWidth: 2),
|
|
)
|
|
: const Icon(Icons.refresh),
|
|
label: const Text('Rescan'),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _TrainerScanResultTile extends StatelessWidget {
|
|
const _TrainerScanResultTile({
|
|
required this.result,
|
|
required this.onTap,
|
|
});
|
|
|
|
final TrainerScanResult result;
|
|
final VoidCallback onTap;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final colorScheme = Theme.of(context).colorScheme;
|
|
final name = result.name.isEmpty ? 'Unknown Trainer' : result.name;
|
|
final typeLabel = result.ftmsDetected ? 'FTMS trainer' : 'Nearby device';
|
|
final addressText = _formatTrainerAddress(result.address);
|
|
|
|
return Material(
|
|
color: colorScheme.surface,
|
|
borderRadius: BorderRadius.circular(22),
|
|
child: InkWell(
|
|
borderRadius: BorderRadius.circular(22),
|
|
onTap: onTap,
|
|
child: Container(
|
|
padding: const EdgeInsets.all(16),
|
|
decoration: BoxDecoration(
|
|
borderRadius: BorderRadius.circular(22),
|
|
border: Border.all(
|
|
color: colorScheme.outlineVariant.withValues(alpha: 0.55),
|
|
),
|
|
),
|
|
child: Row(
|
|
children: [
|
|
Container(
|
|
width: 50,
|
|
height: 50,
|
|
decoration: BoxDecoration(
|
|
shape: BoxShape.circle,
|
|
color: colorScheme.primary.withValues(alpha: 0.12),
|
|
),
|
|
child: Icon(
|
|
Icons.pedal_bike_rounded,
|
|
color: colorScheme.primary,
|
|
),
|
|
),
|
|
const SizedBox(width: 14),
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
name,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: Theme.of(context).textTheme.titleMedium?.copyWith(
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
typeLabel,
|
|
style: Theme.of(context).textTheme.bodyMedium?.copyWith(
|
|
color: colorScheme.primary,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
addressText,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: Theme.of(context).textTheme.bodySmall?.copyWith(
|
|
color:
|
|
colorScheme.onSurface.withValues(alpha: 0.62),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
const SizedBox(width: 12),
|
|
Column(
|
|
crossAxisAlignment: CrossAxisAlignment.end,
|
|
children: [
|
|
_RssiBadge(rssi: result.rssi),
|
|
const SizedBox(height: 12),
|
|
Icon(
|
|
Icons.chevron_right_rounded,
|
|
color: colorScheme.onSurface.withValues(alpha: 0.55),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
String _formatTrainerAddress(TrainerAddress address) {
|
|
final flags = address.flags.toRadixString(16).padLeft(2, '0');
|
|
return '${formatMacAddressFromLittleEndian(address.bytes)} · flags 0x$flags';
|
|
}
|
|
}
|
|
|
|
class _ScanMessage extends StatelessWidget {
|
|
const _ScanMessage({
|
|
required this.message,
|
|
this.action,
|
|
});
|
|
|
|
final String message;
|
|
final Widget? action;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Padding(
|
|
padding: const EdgeInsets.all(20),
|
|
child: Center(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Text(
|
|
message,
|
|
textAlign: TextAlign.center,
|
|
),
|
|
if (action != null) ...[
|
|
const SizedBox(height: 12),
|
|
SizedBox(width: 132, child: action!),
|
|
],
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _RssiBadge extends StatelessWidget {
|
|
const _RssiBadge({required this.rssi});
|
|
|
|
final int rssi;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final color = rssi > -65
|
|
? const Color(0xFF40C979)
|
|
: rssi > -80
|
|
? const Color(0xFFFFB649)
|
|
: Theme.of(context).colorScheme.error;
|
|
|
|
return Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
|
|
decoration: BoxDecoration(
|
|
color: color.withValues(alpha: 0.15),
|
|
borderRadius: BorderRadius.circular(999),
|
|
),
|
|
child: Text(
|
|
'$rssi dBm',
|
|
style: TextStyle(
|
|
color: color,
|
|
fontWeight: FontWeight.w700,
|
|
fontSize: 12,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|