mirror of
https://github.com/dz0ny/meshcore-sar.git
synced 2026-08-11 16:30:28 +00:00
919 lines
29 KiB
Dart
919 lines
29 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:provider/provider.dart';
|
|
|
|
import '../models/contact.dart';
|
|
import '../providers/connection_provider.dart';
|
|
import '../providers/contacts_provider.dart';
|
|
import '../providers/sensors_provider.dart';
|
|
import '../widgets/sensors/sensor_telemetry_card.dart';
|
|
|
|
class SensorsTab extends StatefulWidget {
|
|
final bool isActive;
|
|
|
|
const SensorsTab({super.key, this.isActive = true});
|
|
|
|
@override
|
|
State<SensorsTab> createState() => _SensorsTabState();
|
|
}
|
|
|
|
class _SensorsTabState extends State<SensorsTab> {
|
|
Timer? _minuteTicker;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
if (widget.isActive) {
|
|
unawaited(_handleMinuteTick());
|
|
_scheduleMinuteTicker();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_minuteTicker?.cancel();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(covariant SensorsTab oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
if (oldWidget.isActive == widget.isActive) {
|
|
return;
|
|
}
|
|
|
|
if (widget.isActive) {
|
|
unawaited(_handleMinuteTick());
|
|
_scheduleMinuteTicker();
|
|
return;
|
|
}
|
|
|
|
_minuteTicker?.cancel();
|
|
_minuteTicker = null;
|
|
}
|
|
|
|
void _scheduleMinuteTicker() {
|
|
_minuteTicker?.cancel();
|
|
if (!widget.isActive) {
|
|
return;
|
|
}
|
|
|
|
final now = DateTime.now();
|
|
final nextMinute = DateTime(
|
|
now.year,
|
|
now.month,
|
|
now.day,
|
|
now.hour,
|
|
now.minute + 1,
|
|
);
|
|
final delay = nextMinute.difference(now);
|
|
|
|
_minuteTicker = Timer(delay, () {
|
|
if (!mounted) return;
|
|
unawaited(_handleMinuteTick());
|
|
_minuteTicker = Timer.periodic(const Duration(minutes: 1), (_) {
|
|
unawaited(_handleMinuteTick());
|
|
});
|
|
});
|
|
}
|
|
|
|
Future<void> _handleMinuteTick() async {
|
|
if (!mounted || !widget.isActive) {
|
|
return;
|
|
}
|
|
|
|
final sensorsProvider = context.read<SensorsProvider>();
|
|
sensorsProvider.clearExpiredRefreshStates();
|
|
await sensorsProvider.refreshDueSensors(
|
|
contactsProvider: context.read<ContactsProvider>(),
|
|
connectionProvider: context.read<ConnectionProvider>(),
|
|
now: DateTime.now(),
|
|
);
|
|
if (!mounted) {
|
|
return;
|
|
}
|
|
setState(() {});
|
|
}
|
|
|
|
Future<void> _showAddSensorSheet(BuildContext context) async {
|
|
final sensorsProvider = context.read<SensorsProvider>();
|
|
final contactsProvider = context.read<ContactsProvider>();
|
|
final candidates = sensorsProvider.availableCandidates(contactsProvider);
|
|
|
|
await showModalBottomSheet<void>(
|
|
context: context,
|
|
showDragHandle: true,
|
|
builder: (sheetContext) {
|
|
if (candidates.isEmpty) {
|
|
return const SafeArea(
|
|
child: Padding(
|
|
padding: EdgeInsets.all(24),
|
|
child: Text(
|
|
'No eligible nodes available. Discover a relay or node first.',
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
return SafeArea(
|
|
child: ListView(
|
|
shrinkWrap: true,
|
|
padding: const EdgeInsets.only(bottom: 20),
|
|
children: [
|
|
const ListTile(
|
|
title: Text(
|
|
'Add sensor node',
|
|
style: TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
subtitle: Text('Pick a relay or node to watch in Sensors.'),
|
|
),
|
|
...candidates.map(
|
|
(contact) => ListTile(
|
|
contentPadding: const EdgeInsets.symmetric(
|
|
horizontal: 20,
|
|
vertical: 4,
|
|
),
|
|
leading: CircleAvatar(
|
|
radius: 24,
|
|
backgroundColor: const Color(0xFFDDEAF8),
|
|
child: Icon(
|
|
_typeIcon(contact),
|
|
color: const Color(0xFF1E4F7A),
|
|
),
|
|
),
|
|
title: Text(contact.displayName),
|
|
subtitle: _SensorCandidatePreview(contact: contact),
|
|
isThreeLine: true,
|
|
onTap: () async {
|
|
await sensorsProvider.addSensor(contact);
|
|
if (!sheetContext.mounted) return;
|
|
Navigator.of(sheetContext).pop();
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
SnackBar(
|
|
content: Text(
|
|
'${contact.displayName} added to Sensors',
|
|
),
|
|
),
|
|
);
|
|
},
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Future<void> _showMetricSelector(
|
|
BuildContext context,
|
|
String publicKeyHex,
|
|
Contact? contact,
|
|
) async {
|
|
await Navigator.of(context).push(
|
|
MaterialPageRoute<void>(
|
|
builder: (pageContext) => _SensorCustomizeView(
|
|
publicKeyHex: publicKeyHex,
|
|
initialContact: contact,
|
|
onRenameMetric:
|
|
({
|
|
required BuildContext context,
|
|
required String publicKeyHex,
|
|
required SensorMetricOption option,
|
|
required SensorsProvider sensorsProvider,
|
|
}) {
|
|
return _showMetricRenameDialog(
|
|
context,
|
|
publicKeyHex: publicKeyHex,
|
|
option: option,
|
|
sensorsProvider: sensorsProvider,
|
|
);
|
|
},
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _showMetricRenameDialog(
|
|
BuildContext context, {
|
|
required String publicKeyHex,
|
|
required SensorMetricOption option,
|
|
required SensorsProvider sensorsProvider,
|
|
}) async {
|
|
final controller = TextEditingController(
|
|
text:
|
|
sensorsProvider.labelOverrideFor(publicKeyHex, option.key) ??
|
|
option.defaultLabel,
|
|
);
|
|
final didSave = await showDialog<bool>(
|
|
context: context,
|
|
builder: (dialogContext) => AlertDialog(
|
|
title: const Text('Rename value'),
|
|
content: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
'Set a custom label for ${option.label}.',
|
|
style: Theme.of(dialogContext).textTheme.bodyMedium,
|
|
),
|
|
const SizedBox(height: 12),
|
|
TextField(
|
|
controller: controller,
|
|
autofocus: true,
|
|
decoration: InputDecoration(
|
|
labelText: 'Label',
|
|
hintText: option.defaultLabel,
|
|
),
|
|
textInputAction: TextInputAction.done,
|
|
onSubmitted: (_) => Navigator.of(dialogContext).pop(true),
|
|
),
|
|
],
|
|
),
|
|
actions: [
|
|
if (sensorsProvider.labelOverrideFor(publicKeyHex, option.key) !=
|
|
null)
|
|
TextButton(onPressed: controller.clear, child: const Text('Reset')),
|
|
TextButton(
|
|
onPressed: () => Navigator.of(dialogContext).pop(false),
|
|
child: const Text('Cancel'),
|
|
),
|
|
FilledButton(
|
|
onPressed: () => Navigator.of(dialogContext).pop(true),
|
|
child: const Text('Save'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
if (didSave != true) {
|
|
controller.dispose();
|
|
return;
|
|
}
|
|
|
|
final nextLabel = controller.text.trim();
|
|
await sensorsProvider.setMetricLabel(
|
|
publicKeyHex,
|
|
option.key,
|
|
nextLabel == option.defaultLabel ? null : nextLabel,
|
|
);
|
|
controller.dispose();
|
|
}
|
|
|
|
Future<void> _refreshAll(BuildContext context) async {
|
|
await context.read<SensorsProvider>().refreshAll(
|
|
contactsProvider: context.read<ContactsProvider>(),
|
|
connectionProvider: context.read<ConnectionProvider>(),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Scaffold(
|
|
floatingActionButton: FloatingActionButton(
|
|
onPressed: () => _showAddSensorSheet(context),
|
|
child: const Icon(Icons.add),
|
|
),
|
|
body: Consumer2<SensorsProvider, ContactsProvider>(
|
|
builder: (context, sensorsProvider, contactsProvider, child) {
|
|
final watchedKeys = sensorsProvider.watchedSensorKeys;
|
|
|
|
return RefreshIndicator(
|
|
onRefresh: () => _refreshAll(context),
|
|
child: ListView(
|
|
padding: const EdgeInsets.fromLTRB(16, 16, 16, 96),
|
|
children: [
|
|
if (watchedKeys.isEmpty)
|
|
const _EmptySensorsState()
|
|
else
|
|
...watchedKeys.map((key) {
|
|
Contact? contact;
|
|
for (final entry in contactsProvider.contacts) {
|
|
if (entry.publicKeyHex == key) {
|
|
contact = entry;
|
|
break;
|
|
}
|
|
}
|
|
return SensorTelemetryCard(
|
|
contact: contact,
|
|
state: sensorsProvider.stateFor(key),
|
|
visibleFields: sensorsProvider.visibleFieldsFor(key),
|
|
fieldOrder: sensorsProvider.metricOrderFor(
|
|
key,
|
|
sensorsProvider.visibleFieldsFor(key),
|
|
),
|
|
labelOverrides: sensorsProvider.labelOverridesFor(key),
|
|
fieldSpans: {
|
|
for (final field in sensorsProvider.visibleFieldsFor(
|
|
key,
|
|
))
|
|
field: sensorsProvider.fieldSpanFor(key, field),
|
|
},
|
|
onRemove: () async {
|
|
await sensorsProvider.removeSensor(key);
|
|
},
|
|
onCustomize: () =>
|
|
_showMetricSelector(context, key, contact),
|
|
onRefresh: () => sensorsProvider.refreshSensor(
|
|
publicKeyHex: key,
|
|
contactsProvider: contactsProvider,
|
|
connectionProvider: context.read<ConnectionProvider>(),
|
|
),
|
|
);
|
|
}),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _SensorCustomizeView extends StatelessWidget {
|
|
final String publicKeyHex;
|
|
final Contact? initialContact;
|
|
final Future<void> Function({
|
|
required BuildContext context,
|
|
required String publicKeyHex,
|
|
required SensorMetricOption option,
|
|
required SensorsProvider sensorsProvider,
|
|
})
|
|
onRenameMetric;
|
|
|
|
const _SensorCustomizeView({
|
|
required this.publicKeyHex,
|
|
required this.initialContact,
|
|
required this.onRenameMetric,
|
|
});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Consumer2<SensorsProvider, ContactsProvider>(
|
|
builder: (context, sensorsProvider, contactsProvider, child) {
|
|
Contact? contact = initialContact;
|
|
for (final entry in contactsProvider.contacts) {
|
|
if (entry.publicKeyHex == publicKeyHex) {
|
|
contact = entry;
|
|
break;
|
|
}
|
|
}
|
|
|
|
final visibleFields = sensorsProvider.visibleFieldsFor(publicKeyHex);
|
|
final autoRefreshMinutes = sensorsProvider.autoRefreshMinutesFor(
|
|
publicKeyHex,
|
|
);
|
|
final options = sensorMetricOptionsFor(
|
|
contact,
|
|
labelOverrides: sensorsProvider.labelOverridesFor(publicKeyHex),
|
|
);
|
|
final orderedFieldKeys = sensorsProvider.metricOrderFor(
|
|
publicKeyHex,
|
|
options.map((option) => option.key),
|
|
);
|
|
final optionByKey = <String, SensorMetricOption>{
|
|
for (final option in options) option.key: option,
|
|
};
|
|
final orderedOptions = orderedFieldKeys
|
|
.map((fieldKey) => optionByKey[fieldKey])
|
|
.whereType<SensorMetricOption>()
|
|
.toList(growable: false);
|
|
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
title: Text('Customize ${contact?.displayName ?? 'Sensor'}'),
|
|
),
|
|
body: ListView(
|
|
padding: const EdgeInsets.fromLTRB(16, 16, 16, 24),
|
|
children: [
|
|
_SensorCustomizeSectionCard(
|
|
title: 'Live preview',
|
|
subtitle:
|
|
'Changes apply immediately. This card matches the current dashboard layout for this sensor.',
|
|
child: SensorTelemetryCard(
|
|
contact: contact,
|
|
state: sensorsProvider.stateFor(publicKeyHex),
|
|
visibleFields: visibleFields,
|
|
fieldOrder: sensorsProvider.metricOrderFor(
|
|
publicKeyHex,
|
|
visibleFields,
|
|
),
|
|
labelOverrides: sensorsProvider.labelOverridesFor(
|
|
publicKeyHex,
|
|
),
|
|
fieldSpans: {
|
|
for (final field in visibleFields)
|
|
field: sensorsProvider.fieldSpanFor(publicKeyHex, field),
|
|
},
|
|
margin: EdgeInsets.zero,
|
|
emptyMetricsMessage: 'No telemetry fields available yet.',
|
|
),
|
|
),
|
|
_SensorCustomizeSectionCard(
|
|
title: 'Refresh schedule',
|
|
subtitle:
|
|
'Choose how often this sensor should refresh while your device stays connected.',
|
|
child: SensorAutoRefreshOptions(
|
|
selectedMinutes: autoRefreshMinutes,
|
|
onSelected: (minutes) {
|
|
sensorsProvider.setAutoRefreshMinutes(
|
|
publicKeyHex,
|
|
minutes,
|
|
);
|
|
},
|
|
),
|
|
),
|
|
Padding(
|
|
padding: const EdgeInsets.fromLTRB(4, 8, 4, 12),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
'Field layout',
|
|
style: Theme.of(context).textTheme.titleLarge,
|
|
),
|
|
const SizedBox(height: 6),
|
|
Text(
|
|
'Use the same value-card previews shown on the dashboard to control visibility, labels, width, and order.',
|
|
style: Theme.of(context).textTheme.bodyMedium,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
...orderedOptions.asMap().entries.map((entry) {
|
|
final index = entry.key;
|
|
final option = entry.value;
|
|
final visible = visibleFields.contains(option.key);
|
|
final span = sensorsProvider.fieldSpanFor(
|
|
publicKeyHex,
|
|
option.key,
|
|
);
|
|
return SensorMetricSelectorItem(
|
|
option: option,
|
|
visible: visible,
|
|
span: span,
|
|
canMoveUp: index > 0,
|
|
canMoveDown: index < orderedOptions.length - 1,
|
|
onToggle: (value) {
|
|
sensorsProvider.toggleMetric(
|
|
publicKeyHex,
|
|
option.key,
|
|
value,
|
|
);
|
|
},
|
|
onRename: () => onRenameMetric(
|
|
context: context,
|
|
publicKeyHex: publicKeyHex,
|
|
option: option,
|
|
sensorsProvider: sensorsProvider,
|
|
),
|
|
onMoveUp: index > 0
|
|
? () => sensorsProvider.moveMetric(
|
|
publicKeyHex,
|
|
availableFieldKeys: orderedFieldKeys,
|
|
oldIndex: index,
|
|
newIndex: index - 1,
|
|
)
|
|
: null,
|
|
onMoveDown: index < orderedOptions.length - 1
|
|
? () => sensorsProvider.moveMetric(
|
|
publicKeyHex,
|
|
availableFieldKeys: orderedFieldKeys,
|
|
oldIndex: index,
|
|
newIndex: index + 1,
|
|
)
|
|
: null,
|
|
onSpanChanged: (selection) {
|
|
sensorsProvider.setFieldSpan(
|
|
publicKeyHex,
|
|
option.key,
|
|
selection,
|
|
);
|
|
},
|
|
);
|
|
}),
|
|
],
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
class _SensorCustomizeSectionCard extends StatelessWidget {
|
|
final String title;
|
|
final String subtitle;
|
|
final Widget child;
|
|
|
|
const _SensorCustomizeSectionCard({
|
|
required this.title,
|
|
required this.subtitle,
|
|
required this.child,
|
|
});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final colorScheme = Theme.of(context).colorScheme;
|
|
return Container(
|
|
margin: const EdgeInsets.only(bottom: 16),
|
|
decoration: BoxDecoration(
|
|
borderRadius: BorderRadius.circular(28),
|
|
gradient: LinearGradient(
|
|
begin: Alignment.topLeft,
|
|
end: Alignment.bottomRight,
|
|
colors: [
|
|
colorScheme.surfaceContainerLow,
|
|
colorScheme.surfaceContainerHighest.withValues(alpha: 0.9),
|
|
],
|
|
),
|
|
border: Border.all(
|
|
color: colorScheme.outlineVariant.withValues(alpha: 0.35),
|
|
),
|
|
boxShadow: [
|
|
BoxShadow(
|
|
color: Colors.black.withValues(alpha: 0.045),
|
|
blurRadius: 12,
|
|
offset: const Offset(0, 4),
|
|
),
|
|
],
|
|
),
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(16),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(title, style: Theme.of(context).textTheme.titleMedium),
|
|
const SizedBox(height: 6),
|
|
Text(
|
|
subtitle,
|
|
style: Theme.of(context).textTheme.bodyMedium?.copyWith(
|
|
color: colorScheme.onSurfaceVariant,
|
|
),
|
|
),
|
|
const SizedBox(height: 14),
|
|
child,
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class SensorAutoRefreshOptions extends StatelessWidget {
|
|
final int selectedMinutes;
|
|
final ValueChanged<int> onSelected;
|
|
|
|
const SensorAutoRefreshOptions({
|
|
super.key,
|
|
required this.selectedMinutes,
|
|
required this.onSelected,
|
|
});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Wrap(
|
|
spacing: 8,
|
|
runSpacing: 8,
|
|
children: SensorsProvider.supportedAutoRefreshIntervals
|
|
.map(
|
|
(minutes) => ChoiceChip(
|
|
label: Text(_formatAutoRefreshIntervalLabel(minutes)),
|
|
selected: selectedMinutes == minutes,
|
|
onSelected: (_) => onSelected(minutes),
|
|
),
|
|
)
|
|
.toList(growable: false),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _formatAutoRefreshIntervalLabel(int minutes) {
|
|
if (minutes <= 0) {
|
|
return 'Off';
|
|
}
|
|
if (minutes >= 360 && minutes % 60 == 0) {
|
|
return '${minutes ~/ 60}h';
|
|
}
|
|
return '${minutes}m';
|
|
}
|
|
|
|
class SensorMetricSelectorItem extends StatelessWidget {
|
|
final SensorMetricOption option;
|
|
final bool visible;
|
|
final int span;
|
|
final bool canMoveUp;
|
|
final bool canMoveDown;
|
|
final ValueChanged<bool> onToggle;
|
|
final VoidCallback onRename;
|
|
final VoidCallback? onMoveUp;
|
|
final VoidCallback? onMoveDown;
|
|
final ValueChanged<int> onSpanChanged;
|
|
|
|
const SensorMetricSelectorItem({
|
|
super.key,
|
|
required this.option,
|
|
required this.visible,
|
|
required this.span,
|
|
required this.canMoveUp,
|
|
required this.canMoveDown,
|
|
required this.onToggle,
|
|
required this.onRename,
|
|
this.onMoveUp,
|
|
this.onMoveDown,
|
|
required this.onSpanChanged,
|
|
});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final theme = Theme.of(context);
|
|
final colorScheme = theme.colorScheme;
|
|
final showChannelChip = option.channel != null && option.channel != 1;
|
|
final previewCardData =
|
|
option.previewCardData ??
|
|
SensorMetricCardData(
|
|
fieldKey: option.key,
|
|
icon: Icons.sensors,
|
|
label: option.defaultLabel,
|
|
value: option.valuePreview ?? 'No telemetry yet',
|
|
accent: colorScheme.primary,
|
|
channel: option.channel,
|
|
);
|
|
|
|
return Container(
|
|
margin: const EdgeInsets.only(bottom: 16),
|
|
decoration: BoxDecoration(
|
|
borderRadius: BorderRadius.circular(28),
|
|
gradient: LinearGradient(
|
|
begin: Alignment.topLeft,
|
|
end: Alignment.bottomRight,
|
|
colors: [
|
|
colorScheme.surfaceContainerLow,
|
|
colorScheme.surfaceContainerHighest.withValues(alpha: 0.9),
|
|
],
|
|
),
|
|
border: Border.all(
|
|
color: colorScheme.outlineVariant.withValues(alpha: 0.35),
|
|
),
|
|
boxShadow: [
|
|
BoxShadow(
|
|
color: Colors.black.withValues(alpha: 0.045),
|
|
blurRadius: 12,
|
|
offset: const Offset(0, 4),
|
|
),
|
|
],
|
|
),
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(12),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Row(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
option.defaultLabel,
|
|
style: theme.textTheme.titleSmall?.copyWith(
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
const SizedBox(height: 6),
|
|
Wrap(
|
|
spacing: 8,
|
|
runSpacing: 8,
|
|
crossAxisAlignment: WrapCrossAlignment.center,
|
|
children: [
|
|
TextButton.icon(
|
|
onPressed: onRename,
|
|
style: TextButton.styleFrom(
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: 12,
|
|
vertical: 8,
|
|
),
|
|
foregroundColor: colorScheme.primary,
|
|
textStyle: theme.textTheme.labelLarge?.copyWith(
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
icon: const Icon(Icons.edit_outlined, size: 18),
|
|
label: const Text('Rename'),
|
|
),
|
|
if (showChannelChip)
|
|
Container(
|
|
key: ValueKey(
|
|
'sensor_selector_channel_${option.key}',
|
|
),
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: 10,
|
|
vertical: 8,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: previewCardData.accent.withValues(
|
|
alpha: 0.10,
|
|
),
|
|
borderRadius: BorderRadius.circular(999),
|
|
),
|
|
child: Text(
|
|
'Channel ${option.channel}',
|
|
style: theme.textTheme.labelMedium?.copyWith(
|
|
color: previewCardData.accent,
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
const SizedBox(width: 12),
|
|
Container(
|
|
padding: const EdgeInsets.symmetric(
|
|
horizontal: 10,
|
|
vertical: 5,
|
|
),
|
|
decoration: BoxDecoration(
|
|
color: visible
|
|
? const Color(0xFF218B63).withValues(alpha: 0.12)
|
|
: colorScheme.surfaceContainerHighest,
|
|
borderRadius: BorderRadius.circular(999),
|
|
),
|
|
child: Text(
|
|
visible ? 'Visible' : 'Hidden',
|
|
style: theme.textTheme.labelMedium?.copyWith(
|
|
color: visible
|
|
? const Color(0xFF218B63)
|
|
: colorScheme.onSurfaceVariant,
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 12),
|
|
Opacity(
|
|
opacity: visible ? 1 : 0.55,
|
|
child: SensorMetricTile(
|
|
data: previewCardData,
|
|
width: double.infinity,
|
|
keyPrefix: 'sensor_selector_metric',
|
|
allowMapPreview: false,
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: Text(
|
|
'Show on sensor card',
|
|
style: theme.textTheme.bodyMedium?.copyWith(
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
),
|
|
Switch.adaptive(value: visible, onChanged: onToggle),
|
|
],
|
|
),
|
|
const SizedBox(height: 12),
|
|
Row(
|
|
children: [
|
|
Text(
|
|
'Card width',
|
|
style: theme.textTheme.labelLarge?.copyWith(
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
const Spacer(),
|
|
SegmentedButton<int>(
|
|
segments: const [
|
|
ButtonSegment<int>(value: 1, label: Text('1x')),
|
|
ButtonSegment<int>(value: 2, label: Text('2x')),
|
|
],
|
|
selected: <int>{span},
|
|
onSelectionChanged: (selection) {
|
|
onSpanChanged(selection.first);
|
|
},
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: [
|
|
Text(
|
|
'Order',
|
|
style: theme.textTheme.labelLarge?.copyWith(
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
const Spacer(),
|
|
IconButton(
|
|
tooltip: 'Move up',
|
|
onPressed: canMoveUp ? onMoveUp : null,
|
|
icon: const Icon(Icons.arrow_upward),
|
|
),
|
|
IconButton(
|
|
tooltip: 'Move down',
|
|
onPressed: canMoveDown ? onMoveDown : null,
|
|
icon: const Icon(Icons.arrow_downward),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _SensorCandidatePreview extends StatelessWidget {
|
|
final Contact contact;
|
|
|
|
const _SensorCandidatePreview({required this.contact});
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final telemetry = contact.telemetry;
|
|
final previewLines = <String>[
|
|
'${contact.type.displayName} • ${contact.publicKeyShort}',
|
|
if (telemetry?.batteryPercentage != null)
|
|
'Battery ${telemetry!.batteryPercentage!.toStringAsFixed(0)}% • '
|
|
'Temp ${telemetry.temperature?.toStringAsFixed(1) ?? '--'}°C',
|
|
if (telemetry?.gpsLocation != null)
|
|
'GPS ${telemetry!.gpsLocation!.latitude.toStringAsFixed(3)}, '
|
|
'${telemetry.gpsLocation!.longitude.toStringAsFixed(3)}',
|
|
];
|
|
|
|
if (previewLines.length == 1) {
|
|
previewLines.add('No telemetry preview available yet');
|
|
}
|
|
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: previewLines
|
|
.take(3)
|
|
.map(
|
|
(line) => Text(line, maxLines: 1, overflow: TextOverflow.ellipsis),
|
|
)
|
|
.toList(),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _EmptySensorsState extends StatelessWidget {
|
|
const _EmptySensorsState();
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Padding(
|
|
padding: const EdgeInsets.symmetric(vertical: 64),
|
|
child: Column(
|
|
children: [
|
|
Container(
|
|
width: 84,
|
|
height: 84,
|
|
decoration: const BoxDecoration(
|
|
color: Color(0xFFDDEAF8),
|
|
shape: BoxShape.circle,
|
|
),
|
|
child: const Icon(
|
|
Icons.sensors_outlined,
|
|
size: 40,
|
|
color: Color(0xFF1E4F7A),
|
|
),
|
|
),
|
|
const SizedBox(height: 20),
|
|
Text(
|
|
'No sensor nodes added',
|
|
style: Theme.of(context).textTheme.titleLarge,
|
|
),
|
|
const SizedBox(height: 10),
|
|
const Padding(
|
|
padding: EdgeInsets.symmetric(horizontal: 24),
|
|
child: Text(
|
|
'Use + to add discovered relays or nodes. Pull down to refresh telemetry after adding them.',
|
|
textAlign: TextAlign.center,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
IconData _typeIcon(Contact contact) {
|
|
if (contact.isSensor) {
|
|
return Icons.sensors;
|
|
}
|
|
if (contact.isRepeater) {
|
|
return Icons.router;
|
|
}
|
|
if (contact.isChat) {
|
|
return Icons.person;
|
|
}
|
|
return Icons.device_hub;
|
|
}
|