635 lines
21 KiB
Dart
635 lines
21 KiB
Dart
import 'package:flutter/material.dart';
|
|
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
import 'package:go_router/go_router.dart';
|
|
|
|
import '../../domain/models/floor.dart';
|
|
import '../../domain/models/floor_plan_mode.dart';
|
|
import '../../domain/models/sensor.dart';
|
|
import '../../domain/models/tag.dart';
|
|
import '../../providers.dart';
|
|
import '../ble_provision/ble_provision_sheet.dart';
|
|
import '../sensors/sensor_detail_sheet.dart';
|
|
import 'widgets/floor_plan_editor.dart';
|
|
import 'widgets/room_edit_sheet.dart';
|
|
|
|
class FloorPlanScreen extends ConsumerStatefulWidget {
|
|
const FloorPlanScreen({super.key});
|
|
|
|
@override
|
|
ConsumerState<FloorPlanScreen> createState() => _FloorPlanScreenState();
|
|
}
|
|
|
|
class _FloorPlanScreenState extends ConsumerState<FloorPlanScreen> {
|
|
final _editorKey = GlobalKey<FloorPlanEditorState>();
|
|
|
|
List<Room>? _editModeOriginalRooms;
|
|
List<Room>? _pendingRoomUpdates;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
WidgetsBinding.instance.addPostFrameCallback((_) => _syncAll());
|
|
}
|
|
|
|
void _syncAll() {
|
|
ref
|
|
.read(roomsProvider.future)
|
|
.then((rooms) => _editorKey.currentState?.loadFloorPlan(rooms));
|
|
ref.read(sensorsProvider.future).then((sensors) {
|
|
_editorKey.currentState?.loadSensors(sensors);
|
|
_applyPlacementState();
|
|
});
|
|
}
|
|
|
|
void _applyPlacementState() {
|
|
final placing = ref.read(sensorPlacementProvider);
|
|
if (placing == null) {
|
|
_editorKey.currentState?.highlightSensor(null);
|
|
return;
|
|
}
|
|
final currentMode = ref.read(floorPlanModeProvider);
|
|
if (currentMode != FloorPlanMode.view) {
|
|
ref.read(floorPlanModeProvider.notifier).state = FloorPlanMode.view;
|
|
_editorKey.currentState?.setMode(FloorPlanMode.view);
|
|
}
|
|
if (placing.isPlaced) {
|
|
_editorKey.currentState?.highlightSensor(placing.id.toString());
|
|
}
|
|
}
|
|
|
|
Future<void> _confirmPlacement(Sensor sensor) async {
|
|
final result = await _editorKey.currentState?.getPositionAtCenter();
|
|
if (!mounted) return;
|
|
if (result == null || result.roomId == null) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(content: Text('Move the map so the dot is over a room')),
|
|
);
|
|
return;
|
|
}
|
|
await ref
|
|
.read(sensorRepositoryProvider)
|
|
.placeSensor(
|
|
sensor.id,
|
|
roomId: result.roomId!,
|
|
x: result.x!,
|
|
y: result.y!,
|
|
);
|
|
ref.read(sensorPlacementProvider.notifier).state = null;
|
|
ref.invalidate(sensorsProvider);
|
|
ref.invalidate(sensorProvider(sensor.id));
|
|
}
|
|
|
|
void _cancelPlacement() {
|
|
ref.read(sensorPlacementProvider.notifier).state = null;
|
|
ref.read(sensorPlacementOriginSensorsProvider.notifier).state = false;
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final mode = ref.watch(floorPlanModeProvider);
|
|
final roomsAsync = ref.watch(roomsProvider);
|
|
final sensorsAsync = ref.watch(sensorsProvider);
|
|
final placingSensor = ref.watch(sensorPlacementProvider);
|
|
final trackedTag = ref.watch(trackedTagProvider);
|
|
|
|
ref.listen(roomsProvider, (_, next) {
|
|
next.whenData((r) => _editorKey.currentState?.loadFloorPlan(r));
|
|
});
|
|
ref.listen(sensorsProvider, (_, next) {
|
|
next.whenData((s) => _editorKey.currentState?.loadSensors(s));
|
|
});
|
|
ref.listen(sensorsChannelProvider, (_, next) {
|
|
next.whenData((msg) {
|
|
switch (msg['event'] as String?) {
|
|
case 'sensor_announced':
|
|
ref.invalidate(sensorsProvider);
|
|
case 'sensor_enrollment_timeout':
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text(
|
|
'Sensor did not come online in time. '
|
|
'Check WiFi credentials and try again.',
|
|
),
|
|
),
|
|
);
|
|
}
|
|
});
|
|
});
|
|
ref.listen(tagPositionsProvider, (_, next) {
|
|
next.whenData((t) => _editorKey.currentState?.updateTags(t));
|
|
});
|
|
if (trackedTag != null) {
|
|
ref.listen(particleSnapshotProvider(trackedTag.tagId), (_, next) {
|
|
next.whenData(
|
|
(snap) =>
|
|
_editorKey.currentState?.updateParticleCloud(snap.particles),
|
|
);
|
|
});
|
|
}
|
|
ref.listen(trackedTagProvider, (prev, next) {
|
|
if (next == null) _editorKey.currentState?.updateParticleCloud([]);
|
|
});
|
|
ref.listen(sensorPlacementProvider, (prev, next) => _applyPlacementState());
|
|
|
|
final unplaced =
|
|
sensorsAsync.valueOrNull?.where((s) => !s.isPlaced).toList() ?? [];
|
|
|
|
return PopScope(
|
|
// While placing, intercept back: cancel placement and go to sensors list.
|
|
canPop: placingSensor == null,
|
|
onPopInvokedWithResult: (didPop, _) {
|
|
if (!didPop && placingSensor != null) {
|
|
final fromSensors = ref.read(sensorPlacementOriginSensorsProvider);
|
|
_cancelPlacement();
|
|
if (fromSensors) context.go('/sensors');
|
|
}
|
|
},
|
|
child: Scaffold(
|
|
appBar: AppBar(
|
|
title: const Text('Floor Plan'),
|
|
actions: [
|
|
if (placingSensor == null) ...[
|
|
if (mode == FloorPlanMode.view) ...[
|
|
IconButton(
|
|
tooltip: 'Edit mode',
|
|
icon: const Icon(Icons.edit),
|
|
onPressed: () {
|
|
_editModeOriginalRooms = ref
|
|
.read(roomsProvider)
|
|
.valueOrNull
|
|
?.toList();
|
|
_pendingRoomUpdates = null;
|
|
ref.read(floorPlanModeProvider.notifier).state =
|
|
FloorPlanMode.edit;
|
|
_editorKey.currentState?.setMode(FloorPlanMode.edit);
|
|
},
|
|
),
|
|
IconButton(
|
|
tooltip: 'Sensor move mode',
|
|
icon: const Icon(Icons.sensors),
|
|
onPressed: () {
|
|
ref.read(floorPlanModeProvider.notifier).state =
|
|
FloorPlanMode.sensorMove;
|
|
_editorKey.currentState?.setMode(FloorPlanMode.sensorMove);
|
|
},
|
|
),
|
|
] else ...[
|
|
if (mode == FloorPlanMode.edit) ...[
|
|
IconButton(
|
|
tooltip: 'Discard changes',
|
|
icon: const Icon(Icons.close),
|
|
onPressed: _discardRoomEdits,
|
|
),
|
|
IconButton(
|
|
tooltip: 'Save changes',
|
|
icon: const Icon(Icons.check),
|
|
onPressed: _saveRoomEdits,
|
|
),
|
|
] else
|
|
IconButton(
|
|
tooltip: 'Done',
|
|
icon: const Icon(Icons.check),
|
|
onPressed: () {
|
|
ref.read(floorPlanModeProvider.notifier).state =
|
|
FloorPlanMode.view;
|
|
_editorKey.currentState?.setMode(FloorPlanMode.view);
|
|
},
|
|
),
|
|
],
|
|
],
|
|
],
|
|
),
|
|
body: Column(
|
|
children: [
|
|
Expanded(
|
|
child: Stack(
|
|
children: [
|
|
FloorPlanEditor(
|
|
key: _editorKey,
|
|
mode: mode,
|
|
onSensorTapped: (id) {
|
|
showSensorDetailSheet(context, int.parse(id));
|
|
},
|
|
onSensorMoved: (sensorId, roomId, x, y) async {
|
|
final id = int.parse(sensorId);
|
|
await ref
|
|
.read(sensorRepositoryProvider)
|
|
.placeSensor(id, roomId: roomId, x: x, y: y);
|
|
ref.invalidate(sensorsProvider);
|
|
ref.invalidate(sensorProvider(id));
|
|
},
|
|
onRoomsUpdated: (roomUpdates) {
|
|
setState(() => _pendingRoomUpdates = roomUpdates);
|
|
},
|
|
onRoomAdded: (x, y) => _showAddRoomDialog(x, y),
|
|
onEditRoomTapped: _showRoomEditSheet,
|
|
onAddSensorTapped: () =>
|
|
showModalBottomSheet<void>(
|
|
context: context,
|
|
isScrollControlled: true,
|
|
useRootNavigator: true,
|
|
builder: (_) => const BleProvisionSheet(),
|
|
).then((_) {
|
|
ref.invalidate(sensorsProvider);
|
|
}),
|
|
),
|
|
if (roomsAsync.valueOrNull?.isEmpty ?? false)
|
|
Center(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(
|
|
Icons.map_outlined,
|
|
size: 64,
|
|
color: Colors.grey.shade400,
|
|
),
|
|
const SizedBox(height: 12),
|
|
Text(
|
|
'No rooms yet',
|
|
style: Theme.of(context).textTheme.titleMedium
|
|
?.copyWith(color: Colors.grey.shade600),
|
|
),
|
|
const SizedBox(height: 4),
|
|
Text(
|
|
'Switch to edit mode and tap + to add a room',
|
|
style: Theme.of(context).textTheme.bodySmall
|
|
?.copyWith(color: Colors.grey.shade500),
|
|
textAlign: TextAlign.center,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
// Tracking card overlay
|
|
if (trackedTag != null && placingSensor == null)
|
|
Positioned(
|
|
top: 16,
|
|
left: 16,
|
|
right: 16,
|
|
child: _TrackingCard(
|
|
tag: trackedTag,
|
|
onStop: () {
|
|
ref.read(trackedTagProvider.notifier).state = null;
|
|
},
|
|
),
|
|
),
|
|
// Placement mode overlay
|
|
if (placingSensor != null) ...[
|
|
const Center(child: _PlacementDot()),
|
|
Positioned(
|
|
top: 16,
|
|
left: 16,
|
|
right: 16,
|
|
child: _PlacementCard(
|
|
sensor: placingSensor,
|
|
onPlace: () => _confirmPlacement(placingSensor),
|
|
onCancel: () {
|
|
final fromSensors = ref.read(
|
|
sensorPlacementOriginSensorsProvider,
|
|
);
|
|
_cancelPlacement();
|
|
if (fromSensors) context.go('/sensors');
|
|
},
|
|
),
|
|
),
|
|
],
|
|
],
|
|
),
|
|
),
|
|
if (placingSensor == null &&
|
|
mode == FloorPlanMode.edit &&
|
|
unplaced.isNotEmpty)
|
|
_UnplacedPanel(sensors: unplaced),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _saveRoomEdits() async {
|
|
final updates = _pendingRoomUpdates;
|
|
final originals = _editModeOriginalRooms ?? [];
|
|
_editModeOriginalRooms = null;
|
|
_pendingRoomUpdates = null;
|
|
// Optimistic: switch to view immediately for responsive UX.
|
|
ref.read(floorPlanModeProvider.notifier).state = FloorPlanMode.view;
|
|
_editorKey.currentState?.setMode(FloorPlanMode.view);
|
|
if (updates != null) {
|
|
final floor = ref.read(floorProvider).valueOrNull;
|
|
if (floor != null) {
|
|
final repo = ref.read(floorRepositoryProvider);
|
|
try {
|
|
for (final r in updates) {
|
|
final orig = originals.where((o) => o.id == r.id).firstOrNull;
|
|
if (orig == null || orig != r) {
|
|
await repo.updateRoom(
|
|
floor.id,
|
|
r.id,
|
|
x: r.x,
|
|
y: r.y,
|
|
name: r.name,
|
|
width: r.width,
|
|
height: r.height,
|
|
);
|
|
}
|
|
}
|
|
} catch (_) {
|
|
if (mounted) {
|
|
ScaffoldMessenger.of(context).showSnackBar(
|
|
const SnackBar(
|
|
content: Text('Failed to save floor plan changes'),
|
|
),
|
|
);
|
|
_editorKey.currentState?.loadFloorPlan(originals);
|
|
}
|
|
}
|
|
finally {
|
|
ref.invalidate(roomsProvider);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void _discardRoomEdits() {
|
|
final original = _editModeOriginalRooms;
|
|
_editModeOriginalRooms = null;
|
|
_pendingRoomUpdates = null;
|
|
if (original != null) {
|
|
_editorKey.currentState?.loadFloorPlan(original);
|
|
}
|
|
ref.read(floorPlanModeProvider.notifier).state = FloorPlanMode.view;
|
|
_editorKey.currentState?.setMode(FloorPlanMode.view);
|
|
}
|
|
|
|
void _showRoomEditSheet(int roomId) {
|
|
final room =
|
|
_pendingRoomUpdates?.where((r) => r.id == roomId).firstOrNull ??
|
|
_editModeOriginalRooms?.where((r) => r.id == roomId).firstOrNull;
|
|
if (room == null) return;
|
|
showModalBottomSheet<void>(
|
|
context: context,
|
|
useRootNavigator: true,
|
|
isScrollControlled: true,
|
|
builder: (_) => RoomEditSheet(
|
|
room: room,
|
|
onSaved: (name, width, height) {
|
|
final current =
|
|
_pendingRoomUpdates ??
|
|
(ref.read(roomsProvider).valueOrNull ?? []);
|
|
setState(() {
|
|
_pendingRoomUpdates = current.map((r) {
|
|
if (r.id != roomId) return r;
|
|
return Room(
|
|
id: r.id,
|
|
name: name,
|
|
floorId: r.floorId,
|
|
x: r.x,
|
|
y: r.y,
|
|
width: width,
|
|
height: height,
|
|
);
|
|
}).toList();
|
|
});
|
|
_editorKey.currentState?.loadFloorPlan(_pendingRoomUpdates ?? []);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _showAddRoomDialog(double x, double y) async {
|
|
final nameCtrl = TextEditingController();
|
|
final widthCtrl = TextEditingController(text: '5.0');
|
|
final heightCtrl = TextEditingController(text: '4.0');
|
|
|
|
final confirmed = await showDialog<bool>(
|
|
context: context,
|
|
builder: (ctx) => AlertDialog(
|
|
title: const Text('Add room'),
|
|
content: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
TextField(
|
|
controller: nameCtrl,
|
|
decoration: const InputDecoration(labelText: 'Name'),
|
|
autofocus: true,
|
|
onSubmitted: (_) => Navigator.of(ctx).pop(true),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: TextField(
|
|
controller: widthCtrl,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Width',
|
|
suffixText: 'm',
|
|
),
|
|
keyboardType: const TextInputType.numberWithOptions(
|
|
decimal: true,
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: TextField(
|
|
controller: heightCtrl,
|
|
decoration: const InputDecoration(
|
|
labelText: 'Height',
|
|
suffixText: 'm',
|
|
),
|
|
keyboardType: const TextInputType.numberWithOptions(
|
|
decimal: true,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(ctx).pop(false),
|
|
child: const Text('Cancel'),
|
|
),
|
|
FilledButton(
|
|
onPressed: () => Navigator.of(ctx).pop(true),
|
|
child: const Text('Add'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
|
|
final name = nameCtrl.text.trim();
|
|
final width = double.tryParse(widthCtrl.text) ?? 5.0;
|
|
final height = double.tryParse(heightCtrl.text) ?? 4.0;
|
|
|
|
if (confirmed != true || !mounted) return;
|
|
if (name.isEmpty) return;
|
|
|
|
var floor = ref.read(floorProvider).valueOrNull;
|
|
if (floor == null) {
|
|
floor = await ref
|
|
.read(floorRepositoryProvider)
|
|
.createFloor(name: 'Ground Floor');
|
|
ref.invalidate(floorProvider);
|
|
}
|
|
|
|
await ref
|
|
.read(floorRepositoryProvider)
|
|
.createRoom(
|
|
floor.id,
|
|
name: name,
|
|
width: width,
|
|
height: height,
|
|
x: x,
|
|
y: y,
|
|
);
|
|
ref.invalidate(roomsProvider);
|
|
}
|
|
}
|
|
|
|
class _PlacementDot extends StatelessWidget {
|
|
const _PlacementDot();
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
width: 16,
|
|
height: 16,
|
|
decoration: BoxDecoration(
|
|
shape: BoxShape.circle,
|
|
color: Theme.of(context).colorScheme.primary,
|
|
border: Border.all(color: Colors.white, width: 2),
|
|
boxShadow: const [BoxShadow(blurRadius: 4, color: Colors.black26)],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _TrackingCard extends StatelessWidget {
|
|
const _TrackingCard({required this.tag, required this.onStop});
|
|
|
|
final Tag tag;
|
|
final VoidCallback onStop;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final theme = Theme.of(context);
|
|
return Card(
|
|
elevation: 4,
|
|
child: Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
|
|
child: Row(
|
|
children: [
|
|
const Icon(Icons.label_outline),
|
|
const SizedBox(width: 10),
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Text(tag.name, style: theme.textTheme.labelLarge),
|
|
Text(
|
|
'Tracking particle cloud',
|
|
style: theme.textTheme.bodySmall,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
TextButton(onPressed: onStop, child: const Text('Stop')),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _PlacementCard extends StatelessWidget {
|
|
const _PlacementCard({
|
|
required this.sensor,
|
|
required this.onPlace,
|
|
required this.onCancel,
|
|
});
|
|
|
|
final Sensor sensor;
|
|
final VoidCallback onPlace;
|
|
final VoidCallback onCancel;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final theme = Theme.of(context);
|
|
return Card(
|
|
elevation: 4,
|
|
child: Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
|
|
child: Row(
|
|
children: [
|
|
const Icon(Icons.sensors),
|
|
const SizedBox(width: 10),
|
|
Expanded(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Text(sensor.displayName, style: theme.textTheme.labelLarge),
|
|
Text(
|
|
'Pan to position, then tap Place',
|
|
style: theme.textTheme.bodySmall,
|
|
),
|
|
],
|
|
),
|
|
),
|
|
TextButton(onPressed: onCancel, child: const Text('Cancel')),
|
|
const SizedBox(width: 4),
|
|
FilledButton(onPressed: onPlace, child: const Text('Place')),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _UnplacedPanel extends StatelessWidget {
|
|
const _UnplacedPanel({required this.sensors});
|
|
|
|
final List<Sensor> sensors;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
color: Theme.of(context).colorScheme.surfaceContainerLow,
|
|
padding: const EdgeInsets.fromLTRB(16, 8, 16, 8),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Text(
|
|
'Unplaced sensors',
|
|
style: Theme.of(context).textTheme.labelSmall,
|
|
),
|
|
const SizedBox(height: 4),
|
|
SingleChildScrollView(
|
|
scrollDirection: Axis.horizontal,
|
|
child: Row(
|
|
children: sensors
|
|
.map(
|
|
(s) => Padding(
|
|
padding: const EdgeInsets.only(right: 8),
|
|
child: ActionChip(
|
|
avatar: const Icon(
|
|
Icons.sensors_off_outlined,
|
|
size: 16,
|
|
),
|
|
label: Text(s.displayName),
|
|
onPressed: () => showSensorDetailSheet(context, s.id),
|
|
),
|
|
),
|
|
)
|
|
.toList(),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|