feat: add background services and map status management

lib/main.dart

@@ -1,14 +1,20 @@
 import 'package:flutter/material.dart';
+import 'package:flutter_local_notifications/flutter_local_notifications.dart';
 import 'package:lbjconsole/screens/main_screen.dart';
 import 'package:lbjconsole/util/train_type_util.dart';
 import 'package:lbjconsole/util/loco_info_util.dart';
 import 'package:lbjconsole/util/loco_type_util.dart';
 import 'package:lbjconsole/services/loco_type_service.dart';
 import 'package:lbjconsole/services/database_service.dart';
+import 'package:lbjconsole/services/background_service.dart';
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
 
+  await _initializeNotifications();
+  
+  await BackgroundService.initialize();
+
   await Future.wait([
     TrainTypeUtil.initialize(),
     LocoInfoUtil.initialize(),
@@ -18,6 +24,19 @@ void main() async {
   runApp(const LBJReceiverApp());
 }
 
+Future<void> _initializeNotifications() async {
+  final flutterLocalNotificationsPlugin = FlutterLocalNotificationsPlugin();
+  
+  const AndroidInitializationSettings initializationSettingsAndroid =
+      AndroidInitializationSettings('@mipmap/ic_launcher');
+      
+  const InitializationSettings initializationSettings = InitializationSettings(
+    android: initializationSettingsAndroid,
+  );
+  
+  await flutterLocalNotificationsPlugin.initialize(initializationSettings);
+}
+
 class LBJReceiverApp extends StatelessWidget {
   const LBJReceiverApp({super.key});
 

lib/models/map_state.dart

@@ -0,0 +1,65 @@
+class MapState {
+  final double zoom;
+  final double centerLat;
+  final double centerLng;
+  final double bearing;
+
+  MapState({
+    required this.zoom,
+    required this.centerLat,
+    required this.centerLng,
+    required this.bearing,
+  });
+
+  Map<String, dynamic> toJson() {
+    return {
+      'zoom': zoom,
+      'centerLat': centerLat,
+      'centerLng': centerLng,
+      'bearing': bearing,
+    };
+  }
+
+  factory MapState.fromJson(Map<String, dynamic> json) {
+    return MapState(
+      zoom: json['zoom']?.toDouble() ?? 10.0,
+      centerLat: json['centerLat']?.toDouble() ?? 39.9042,
+      centerLng: json['centerLng']?.toDouble() ?? 116.4074,
+      bearing: json['bearing']?.toDouble() ?? 0.0,
+    );
+  }
+
+  MapState copyWith({
+    double? zoom,
+    double? centerLat,
+    double? centerLng,
+    double? bearing,
+  }) {
+    return MapState(
+      zoom: zoom ?? this.zoom,
+      centerLat: centerLat ?? this.centerLat,
+      centerLng: centerLng ?? this.centerLng,
+      bearing: bearing ?? this.bearing,
+    );
+  }
+
+  @override
+  String toString() {
+    return 'MapState(zoom: ' + zoom.toString() + ', centerLat: ' + centerLat.toString() + ', centerLng: ' + centerLng.toString() + ', bearing: ' + bearing.toString() + ')';
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is MapState &&
+        other.zoom == zoom &&
+        other.centerLat == centerLat &&
+        other.centerLng == centerLng &&
+        other.bearing == bearing;
+  }
+
+  @override
+  int get hashCode {
+    return zoom.hashCode ^ centerLat.hashCode ^ centerLng.hashCode ^ bearing.hashCode;
+  }
+}

lib/screens/history_screen.dart

@@ -7,6 +7,8 @@ import '../models/merged_record.dart';
 import '../services/database_service.dart';
 import '../models/train_record.dart';
 import '../services/merge_service.dart';
+import '../models/map_state.dart';
+import '../services/map_state_service.dart';
 
 class HistoryScreen extends StatefulWidget {
   final Function(bool isEditing) onEditModeChanged;
@@ -53,7 +55,6 @@ class HistoryScreenState extends State<HistoryScreen> {
   @override
   void initState() {
     super.initState();
-    loadRecords();
     _scrollController.addListener(() {
       if (_scrollController.position.atEdge) {
         if (_scrollController.position.pixels == 0) {
@@ -63,6 +64,9 @@ class HistoryScreenState extends State<HistoryScreen> {
         if (_isAtTop) setState(() => _isAtTop = false);
       }
     });
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (mounted) loadRecords();
+    });
   }
 
   @override
@@ -72,7 +76,6 @@ class HistoryScreenState extends State<HistoryScreen> {
   }
 
   Future<void> loadRecords({bool scrollToTop = true}) async {
-    if (mounted) setState(() => _isLoading = true);
     try {
       final allRecords = await DatabaseService.instance.getAllRecords();
       final settingsMap = await DatabaseService.instance.getAllSettings() ?? {};
@@ -80,15 +83,22 @@ class HistoryScreenState extends State<HistoryScreen> {
       final items = MergeService.getMixedList(allRecords, _mergeSettings);
 
       if (mounted) {
-        setState(() {
-          _displayItems.clear();
-          _displayItems.addAll(items);
-          _isLoading = false;
-        });
-        if (scrollToTop && (_isAtTop) && _scrollController.hasClients) {
-          _scrollController.animateTo(0.0,
-              duration: const Duration(milliseconds: 300),
-              curve: Curves.easeOut);
+        final hasDataChanged = _hasDataChanged(items);
+
+        if (hasDataChanged) {
+          setState(() {
+            _displayItems.clear();
+            _displayItems.addAll(items);
+            _isLoading = false;
+          });
+
+          if (scrollToTop && _isAtTop && _scrollController.hasClients) {
+            _scrollController.jumpTo(0.0);
+          }
+        } else {
+          if (_isLoading) {
+            setState(() => _isLoading = false);
+          }
         }
       }
     } catch (e) {
@@ -96,9 +106,63 @@ class HistoryScreenState extends State<HistoryScreen> {
     }
   }
 
+  Future<void> addNewRecord(TrainRecord newRecord) async {
+    try {
+      final settingsMap = await DatabaseService.instance.getAllSettings() ?? {};
+      _mergeSettings = MergeSettings.fromMap(settingsMap);
+
+      final isNewRecord = !_displayItems.any((item) {
+        if (item is TrainRecord) {
+          return item.uniqueId == newRecord.uniqueId;
+        } else if (item is MergedTrainRecord) {
+          return item.records.any((r) => r.uniqueId == newRecord.uniqueId);
+        }
+        return false;
+      });
+
+      if (!isNewRecord) return;
+
+      if (mounted) {
+        final allRecords = await DatabaseService.instance.getAllRecords();
+        final items = MergeService.getMixedList(allRecords, _mergeSettings);
+
+        setState(() {
+          _displayItems.clear();
+          _displayItems.addAll(items);
+        });
+
+        if (_isAtTop && _scrollController.hasClients) {
+          _scrollController.jumpTo(0.0);
+        }
+      }
+    } catch (e) {
+      print('添加新纪录失败: $e');
+    }
+  }
+
+  bool _hasDataChanged(List<Object> newItems) {
+    if (_displayItems.length != newItems.length) return true;
+
+    for (int i = 0; i < _displayItems.length; i++) {
+      final oldItem = _displayItems[i];
+      final newItem = newItems[i];
+
+      if (oldItem.runtimeType != newItem.runtimeType) return true;
+
+      if (oldItem is TrainRecord && newItem is TrainRecord) {
+        if (oldItem.uniqueId != newItem.uniqueId) return true;
+      } else if (oldItem is MergedTrainRecord && newItem is MergedTrainRecord) {
+        if (oldItem.groupKey != newItem.groupKey) return true;
+        if (oldItem.records.length != newItem.records.length) return true;
+      }
+    }
+
+    return false;
+  }
+
   @override
   Widget build(BuildContext context) {
-    if (_isLoading) {
+    if (_isLoading && _displayItems.isEmpty) {
       return const Center(child: CircularProgressIndicator());
     }
     if (_displayItems.isEmpty) {
@@ -197,7 +261,7 @@ class HistoryScreenState extends State<HistoryScreen> {
     return Column(
       crossAxisAlignment: CrossAxisAlignment.start,
       children: [
-        _buildExpandedMapForAll(mergedRecord.records),
+        _buildExpandedMapForAll(mergedRecord.records, mergedRecord.groupKey),
         const Divider(color: Colors.white24, height: 24),
         ...mergedRecord.records.map((record) => _buildSubRecordItem(
             record, mergedRecord.latestRecord, _mergeSettings.groupBy)),
@@ -353,7 +417,7 @@ class HistoryScreenState extends State<HistoryScreen> {
     return parts.join(' ');
   }
 
-  Widget _buildExpandedMapForAll(List<TrainRecord> records) {
+  Widget _buildExpandedMapForAll(List<TrainRecord> records, String groupKey) {
     final positions = records
         .map((record) => _parsePosition(record.positionInfo))
         .whereType<LatLng>()
@@ -410,6 +474,7 @@ class HistoryScreenState extends State<HistoryScreen> {
             positions: positions,
             center: bounds.center,
             zoom: zoomLevel,
+            groupKey: groupKey,
           ))
     ]);
   }
@@ -664,6 +729,7 @@ class HistoryScreenState extends State<HistoryScreen> {
             key: ValueKey('map_${mapId}_$zoomLevel'),
             position: position,
             zoom: zoomLevel,
+            recordId: record.uniqueId,
           ))
     ]);
   }
@@ -803,11 +869,13 @@ _BoundaryBox _calculateBoundaryBoxIsolate(List<LatLng> positions) {
 class _DelayedMapWithMarker extends StatefulWidget {
   final LatLng position;
   final double zoom;
+  final String recordId;
 
   const _DelayedMapWithMarker({
     Key? key,
     required this.position,
     required this.zoom,
+    required this.recordId,
   }) : super(key: key);
 
   @override
@@ -815,11 +883,90 @@ class _DelayedMapWithMarker extends StatefulWidget {
 }
 
 class _DelayedMapWithMarkerState extends State<_DelayedMapWithMarker> {
+  late final MapController _mapController;
+  late final String _mapKey;
+  bool _isInitializing = true;
+
+  @override
+  void initState() {
+    super.initState();
+    _mapController = MapController();
+    _mapKey = MapStateService.instance.getSingleRecordMapKey(widget.recordId);
+    _initializeMapState();
+  }
+
+  Future<void> _initializeMapState() async {
+    final savedState = await MapStateService.instance.getMapState(_mapKey);
+    if (savedState != null && mounted) {
+      _mapController.move(
+        LatLng(savedState.centerLat, savedState.centerLng),
+        savedState.zoom,
+      );
+      if (savedState.bearing != 0.0) {
+        _mapController.rotate(savedState.bearing);
+      }
+    }
+    setState(() {
+      _isInitializing = false;
+    });
+  }
+
+  void _onCameraMove() {
+    if (_isInitializing) return;
+
+    final camera = _mapController.camera;
+    final state = MapState(
+      zoom: camera.zoom,
+      centerLat: camera.center.latitude,
+      centerLng: camera.center.longitude,
+      bearing: camera.rotation,
+    );
+
+    MapStateService.instance.saveMapState(_mapKey, state);
+  }
+
+  @override
+  void dispose() {
+    _mapController.dispose();
+    super.dispose();
+  }
+
   @override
   Widget build(BuildContext context) {
+    if (_isInitializing) {
+      return FlutterMap(
+        options: MapOptions(
+          initialCenter: widget.position,
+          initialZoom: widget.zoom,
+          onPositionChanged: (position, hasGesture) => _onCameraMove(),
+        ),
+        mapController: _mapController,
+        children: [
+          TileLayer(
+              urlTemplate: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
+              userAgentPackageName: 'org.noxylva.lbjconsole'),
+          MarkerLayer(markers: [
+            Marker(
+                point: widget.position,
+                width: 40,
+                height: 40,
+                child: Container(
+                    decoration: BoxDecoration(
+                        color: Colors.red,
+                        borderRadius: BorderRadius.circular(20),
+                        border: Border.all(color: Colors.white, width: 2)),
+                    child:
+                        const Icon(Icons.train, color: Colors.white, size: 20)))
+          ])
+        ],
+      );
+    }
+
     return FlutterMap(
-      options:
-          MapOptions(initialCenter: widget.position, initialZoom: widget.zoom),
+      options: MapOptions(
+        onPositionChanged: (position, hasGesture) => _onCameraMove(),
+      ),
+      mapController: _mapController,
       children: [
         TileLayer(
             urlTemplate: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
@@ -846,12 +993,14 @@ class _DelayedMultiMarkerMap extends StatefulWidget {
   final List<LatLng> positions;
   final LatLng center;
   final double zoom;
+  final String groupKey;
 
   const _DelayedMultiMarkerMap({
     Key? key,
     required this.positions,
     required this.center,
     required this.zoom,
+    required this.groupKey,
   }) : super(key: key);
 
   @override
@@ -859,15 +1008,65 @@ class _DelayedMultiMarkerMap extends StatefulWidget {
 }
 
 class _DelayedMultiMarkerMapState extends State<_DelayedMultiMarkerMap> {
+  late final MapController _mapController;
+  late final String _mapKey;
+  bool _isInitializing = true;
+
+  @override
+  void initState() {
+    super.initState();
+    _mapController = MapController();
+    _mapKey = MapStateService.instance.getMergedRecordMapKey(widget.groupKey);
+    _initializeMapState();
+  }
+
+  Future<void> _initializeMapState() async {
+    final savedState = await MapStateService.instance.getMapState(_mapKey);
+    if (savedState != null && mounted) {
+      _mapController.move(
+        LatLng(savedState.centerLat, savedState.centerLng),
+        savedState.zoom,
+      );
+      if (savedState.bearing != 0.0) {
+        _mapController.rotate(savedState.bearing);
+      }
+    } else if (mounted) {
+      _mapController.move(widget.center, widget.zoom);
+    }
+    setState(() {
+      _isInitializing = false;
+    });
+  }
+
+  void _onCameraMove() {
+    if (_isInitializing) return;
+
+    final camera = _mapController.camera;
+    final state = MapState(
+      zoom: camera.zoom,
+      centerLat: camera.center.latitude,
+      centerLng: camera.center.longitude,
+      bearing: camera.rotation,
+    );
+
+    MapStateService.instance.saveMapState(_mapKey, state);
+  }
+
+  @override
+  void dispose() {
+    _mapController.dispose();
+    super.dispose();
+  }
+
   @override
   Widget build(BuildContext context) {
     return FlutterMap(
       options: MapOptions(
-        initialCenter: widget.center,
-        initialZoom: widget.zoom,
+        onPositionChanged: (position, hasGesture) => _onCameraMove(),
         minZoom: 5,
         maxZoom: 18,
       ),
+      mapController: _mapController,
       children: [
         TileLayer(
           urlTemplate: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',

lib/screens/main_screen.dart

@@ -10,6 +10,7 @@ import 'package:lbjconsole/screens/settings_screen.dart';
 import 'package:lbjconsole/services/ble_service.dart';
 import 'package:lbjconsole/services/database_service.dart';
 import 'package:lbjconsole/services/notification_service.dart';
+import 'package:lbjconsole/services/background_service.dart';
 import 'package:lbjconsole/themes/app_theme.dart';
 
 class MainScreen extends StatefulWidget {
@@ -39,6 +40,16 @@ class _MainScreenState extends State<MainScreen> with WidgetsBindingObserver {
     _bleService = BLEService();
     _bleService.initialize();
     _initializeServices();
+    _checkAndStartBackgroundService();
+  }
+
+  Future<void> _checkAndStartBackgroundService() async {
+    final settings = await DatabaseService.instance.getAllSettings() ?? {};
+    final backgroundServiceEnabled = (settings['backgroundServiceEnabled'] ?? 0) == 1;
+    
+    if (backgroundServiceEnabled) {
+      await BackgroundService.startService();
+    }
   }
 
   @override
@@ -66,7 +77,7 @@ class _MainScreenState extends State<MainScreen> with WidgetsBindingObserver {
     _dataSubscription = _bleService.dataStream.listen((record) {
       _notificationService.showTrainNotification(record);
       if (_historyScreenKey.currentState != null) {
-        _historyScreenKey.currentState!.loadRecords(scrollToTop: true);
+        _historyScreenKey.currentState!.addNewRecord(record);
       }
     });
   }

lib/screens/settings_screen.dart

@@ -5,6 +5,7 @@ import 'dart:io';
 import 'package:lbjconsole/models/merged_record.dart';
 import 'package:lbjconsole/services/database_service.dart';
 import 'package:lbjconsole/services/ble_service.dart';
+import 'package:lbjconsole/services/background_service.dart';
 import 'package:lbjconsole/themes/app_theme.dart';
 import 'package:url_launcher/url_launcher.dart';
 
@@ -196,11 +197,17 @@ class _SettingsScreenState extends State<SettingsScreen> {
                 ),
                 Switch(
                   value: _backgroundServiceEnabled,
-                  onChanged: (value) {
+                  onChanged: (value) async {
                     setState(() {
                       _backgroundServiceEnabled = value;
                     });
-                    _saveSettings();
+                    await _saveSettings();
+
+                    if (value) {
+                      await BackgroundService.startService();
+                    } else {
+                      await BackgroundService.stopService();
+                    }
                   },
                   activeColor: Theme.of(context).colorScheme.primary,
                 ),
@@ -503,8 +510,6 @@ class _SettingsScreenState extends State<SettingsScreen> {
     }
   }
 
-
-
   Future<void> _shareData() async {
     final scaffoldMessenger = ScaffoldMessenger.of(context);
 
@@ -530,7 +535,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
         if (exportedPath != null) {
           final file = File(exportedPath);
           final fileName = file.path.split(Platform.pathSeparator).last;
-          
+
           await Share.shareXFiles(
             [XFile(file.path)],
             subject: 'LBJ Console Data',
@@ -735,7 +740,8 @@ class _SettingsScreenState extends State<SettingsScreen> {
                 if (snapshot.hasData) {
                   return Text(snapshot.data!, style: AppTheme.bodyMedium);
                 } else {
-                  return const Text('v0.1.3-flutter', style: AppTheme.bodyMedium);
+                  return const Text('v0.1.3-flutter',
+                      style: AppTheme.bodyMedium);
                 }
               },
             ),

lib/services/background_service.dart

@@ -0,0 +1,211 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:ui';
+
+import 'package:flutter_background_service/flutter_background_service.dart';
+import 'package:flutter_background_service_android/flutter_background_service_android.dart';
+import 'package:flutter_local_notifications/flutter_local_notifications.dart';
+import 'package:lbjconsole/services/ble_service.dart';
+
+const String _notificationChannelId = 'lbj_console_channel';
+const String _notificationChannelName = 'LBJ Console 后台服务';
+const String _notificationChannelDescription = '保持蓝牙连接稳定';
+const int _notificationId = 114514;
+
+class BackgroundService {
+  static final FlutterBackgroundService _service = FlutterBackgroundService();
+  static bool _isInitialized = false;
+
+  static Future<void> initialize() async {
+    if (_isInitialized) return;
+
+    final service = FlutterBackgroundService();
+    
+    final flutterLocalNotificationsPlugin = FlutterLocalNotificationsPlugin();
+    
+    if (Platform.isAndroid) {
+      const AndroidNotificationChannel channel = AndroidNotificationChannel(
+        _notificationChannelId,
+        _notificationChannelName,
+        description: _notificationChannelDescription,
+        importance: Importance.low,
+        enableLights: false,
+        enableVibration: false,
+        playSound: false,
+      );
+
+      await flutterLocalNotificationsPlugin.resolvePlatformSpecificImplementation<
+          AndroidFlutterLocalNotificationsPlugin>()?.createNotificationChannel(channel);
+    }
+    
+    await service.configure(
+      androidConfiguration: AndroidConfiguration(
+        onStart: _onStart,
+        autoStart: true,
+        isForegroundMode: true,
+        notificationChannelId: _notificationChannelId,
+        initialNotificationTitle: 'LBJ Console',
+        initialNotificationContent: '蓝牙连接监控中',
+        foregroundServiceNotificationId: _notificationId,
+      ),
+      iosConfiguration: IosConfiguration(
+        autoStart: true,
+        onForeground: _onStart,
+        onBackground: _onIosBackground,
+      ),
+    );
+
+    _isInitialized = true;
+  }
+
+  @pragma('vm:entry-point')
+  static void _onStart(ServiceInstance service) async {
+    DartPluginRegistrant.ensureInitialized();
+
+    if (service is AndroidServiceInstance) {
+      service.on('setAsForeground').listen((event) {
+        service.setAsForegroundService();
+      });
+
+      service.on('setAsBackground').listen((event) {
+        service.setAsBackgroundService();
+      });
+    }
+
+    service.on('stopService').listen((event) {
+      service.stopSelf();
+    });
+
+    BLEService().initialize();
+
+    if (service is AndroidServiceInstance) {
+      await Future.delayed(const Duration(seconds: 1));
+      if (await service.isForegroundService()) {
+        final flutterLocalNotificationsPlugin = FlutterLocalNotificationsPlugin();
+        
+        try {
+          const AndroidNotificationChannel channel = AndroidNotificationChannel(
+            _notificationChannelId,
+            _notificationChannelName,
+            description: _notificationChannelDescription,
+            importance: Importance.low,
+            enableLights: false,
+            enableVibration: false,
+            playSound: false,
+          );
+
+          await flutterLocalNotificationsPlugin.resolvePlatformSpecificImplementation<
+              AndroidFlutterLocalNotificationsPlugin>()?.createNotificationChannel(channel);
+
+          await flutterLocalNotificationsPlugin.show(
+            _notificationId,
+            'LBJ Console',
+            '蓝牙连接监控中',
+            NotificationDetails(
+              android: AndroidNotificationDetails(
+                _notificationChannelId,
+                _notificationChannelName,
+                channelDescription: _notificationChannelDescription,
+                icon: '@mipmap/ic_launcher',
+                ongoing: true,
+                autoCancel: false,
+                importance: Importance.low,
+                priority: Priority.low,
+                enableLights: false,
+                enableVibration: false,
+                playSound: false,
+                onlyAlertOnce: true,
+                setAsGroupSummary: false,
+                groupKey: 'lbj_console_group',
+                visibility: NotificationVisibility.public,
+                category: AndroidNotificationCategory.service,
+              ),
+            ),
+          );
+          print('前台服务通知显示成功');
+        } catch (e) {
+          print('前台服务通知显示失败: $e');
+        }
+      }
+    }
+
+    Timer.periodic(const Duration(seconds: 30), (timer) async {
+      if (service is AndroidServiceInstance) {
+        if (await service.isForegroundService()) {
+          try {
+            final bleService = BLEService();
+            final isConnected = bleService.isConnected;
+            final deviceStatus = bleService.deviceStatus;
+            
+            final flutterLocalNotificationsPlugin = FlutterLocalNotificationsPlugin();
+            await flutterLocalNotificationsPlugin.show(
+              _notificationId,
+              'LBJ Console',
+              isConnected ? '蓝牙已连接 - $deviceStatus' : '蓝牙未连接 - 自动重连中',
+              NotificationDetails(
+                android: AndroidNotificationDetails(
+                  _notificationChannelId,
+                  _notificationChannelName,
+                  channelDescription: _notificationChannelDescription,
+                  icon: '@mipmap/ic_launcher',
+                  ongoing: true,
+                  autoCancel: false,
+                  importance: Importance.low,
+                  priority: Priority.low,
+                  enableLights: false,
+                  enableVibration: false,
+                  playSound: false,
+                  onlyAlertOnce: true,
+                  setAsGroupSummary: false,
+                  groupKey: 'lbj_console_group',
+                  visibility: NotificationVisibility.public,
+                  category: AndroidNotificationCategory.service,
+                ),
+              ),
+            );
+          } catch (e) {
+            print('前台服务通知更新失败: $e');
+          }
+        }
+      }
+    });
+  }
+
+  @pragma('vm:entry-point')
+  static Future<bool> _onIosBackground(ServiceInstance service) async {
+    return true;
+  }
+
+  static Future<void> startService() async {
+    await initialize();
+    final service = FlutterBackgroundService();
+    
+    if (Platform.isAndroid) {
+      final isRunning = await service.isRunning();
+      if (!isRunning) {
+        service.startService();
+      }
+    } else if (Platform.isIOS) {
+      service.startService();
+    }
+  }
+
+  static Future<void> stopService() async {
+    final service = FlutterBackgroundService();
+    service.invoke('stopService');
+  }
+
+  static Future<bool> isRunning() async {
+    final service = FlutterBackgroundService();
+    return await service.isRunning();
+  }
+
+  static void setForegroundMode(bool isForeground) {
+    final service = FlutterBackgroundService();
+    if (isForeground) {
+      service.invoke('setAsForeground');
+    } else {
+      service.invoke('setAsBackground');
+    }
+  }
+}

lib/services/map_state_service.dart

@@ -0,0 +1,113 @@
+import 'dart:convert';
+import 'package:sqflite/sqflite.dart';
+import 'package:lbjconsole/models/map_state.dart';
+import 'database_service.dart';
+
+class MapStateService {
+  static final MapStateService instance = MapStateService._internal();
+  factory MapStateService() => instance;
+  MapStateService._internal();
+
+  static const String _tableName = 'record_map_states';
+  
+  final Map<String, MapState> _memoryCache = {};
+
+  Future<void> _ensureTableExists() async {
+    final db = await DatabaseService.instance.database;
+    await db.execute('''
+      CREATE TABLE IF NOT EXISTS $_tableName (
+        key TEXT PRIMARY KEY,
+        state TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    ''');
+  }
+
+  String getSingleRecordMapKey(String recordId) {
+    return "${recordId}_record_map";
+  }
+
+  String getMergedRecordMapKey(String groupKey) {
+    return "${groupKey}_group_map";
+  }
+
+  Future<void> saveMapState(String key, MapState state) async {
+    try {
+      _memoryCache[key] = state;
+      
+      final db = await DatabaseService.instance.database;
+      await _ensureTableExists();
+      
+      await db.insert(
+        _tableName,
+        {
+          'key': key,
+          'state': jsonEncode(state.toJson()),
+          'updated_at': DateTime.now().millisecondsSinceEpoch,
+        },
+        conflictAlgorithm: ConflictAlgorithm.replace,
+      );
+    } catch (e) {
+      print('保存地图状态失败: $e');
+    }
+  }
+
+  Future<MapState?> getMapState(String key) async {
+    if (_memoryCache.containsKey(key)) {
+      return _memoryCache[key];
+    }
+
+    try {
+      final db = await DatabaseService.instance.database;
+      await _ensureTableExists();
+      
+      final result = await db.query(
+        _tableName,
+        where: 'key = ?',
+        whereArgs: [key],
+        limit: 1,
+      );
+
+      if (result.isNotEmpty) {
+        final stateJson = jsonDecode(result.first['state'] as String);
+        final state = MapState.fromJson(stateJson);
+        _memoryCache[key] = state;
+        return state;
+      }
+    } catch (e) {
+      print('读取地图状态失败: $e');
+    }
+    
+    return null;
+  }
+
+  Future<void> deleteMapState(String key) async {
+    _memoryCache.remove(key);
+    
+    try {
+      final db = await DatabaseService.instance.database;
+      await db.delete(
+        _tableName,
+        where: 'key = ?',
+        whereArgs: [key],
+      );
+    } catch (e) {
+      print('删除地图状态失败: $e');
+    }
+  }
+
+  Future<void> clearAllMapStates() async {
+    _memoryCache.clear();
+    
+    try {
+      final db = await DatabaseService.instance.database;
+      await db.delete(_tableName);
+    } catch (e) {
+      print('清空地图状态失败: $e');
+    }
+  }
+
+  void clearMemoryCache() {
+    _memoryCache.clear();
+  }
+}