feat: Implement Day-12 Responder Activation System

Author: Anbu-00001

mobile_app/lib/controllers/responder_controller.dart

@@ -0,0 +1,71 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import '../services/responder_state_service.dart';
+import '../services/location_service.dart';
+import '../services/tile_prefetch_service.dart';
+
+/// Acts as the glue: listens to [ResponderStateService]. When active, it uses
+/// [LocationService] to get the location, and then triggers an offline tile
+/// prefetch centered around the responder for 5km using [TilePrefetchService].
+class ResponderController {
+  final ResponderStateService _stateService;
+  final LocationService _locationService;
+  final TilePrefetchService _prefetchService;
+
+  StreamSubscription<ResponderState>? _stateSub;
+  bool _hasTriggeredForCurrentSession = false;
+
+  ResponderController({
+    required ResponderStateService stateService,
+    required LocationService locationService,
+    required TilePrefetchService prefetchService,
+  })  : _stateService = stateService,
+        _locationService = locationService,
+        _prefetchService = prefetchService {
+    _init();
+  }
+
+  void _init() {
+    _stateSub = _stateService.stateStream.listen(_onStateChanged);
+    
+    // Check initial state
+    _onStateChanged(_stateService.currentState);
+  }
+
+  Future<void> _onStateChanged(ResponderState state) async {
+    if (state == ResponderState.inactive) {
+      _hasTriggeredForCurrentSession = false;
+      return;
+    }
+
+    if (state == ResponderState.active) {
+      if (_hasTriggeredForCurrentSession) return;
+      _hasTriggeredForCurrentSession = true;
+
+      // 1. Get the current location
+      final location = await _locationService.getCurrentLocation();
+      
+      if (location == null) {
+        debugPrint('ResponderController: Failed to get location, skipping tile prefetch');
+        return;
+      }
+
+      // 2. Trigger tile prefetch for 5km radius
+      debugPrint('Starting tile prefetch for radius');
+      
+      try {
+        await _prefetchService.startPrefetchForRadius(
+          location,
+          5000, // 5km radius
+        );
+      } catch (e) {
+        debugPrint('ResponderController: Failed to start prefetch: $e');
+      }
+    }
+  }
+
+  void dispose() {
+    _stateSub?.cancel();
+  }
+}

mobile_app/lib/features/map/map_screen.dart

@@ -13,6 +13,7 @@ import '../../models/models.dart' as models;
 import '../messaging/messaging_screen.dart';
 import '../prefetch/prefetch_screen.dart';
 import 'map_service.dart';
+import '../../widgets/responder_toggle.dart';
 
 // Temporarily disabled for tile debugging:
 // import 'package:maplibre_gl/maplibre_gl.dart';
@@ -653,9 +654,18 @@ class _MapScreenState extends State<MapScreen> {
                     ),
                 ],
               ),
-      floatingActionButton: FloatingActionButton(
-        onPressed: () => _openCreateIncidentForm(),
-        child: const Icon(Icons.add_location_alt),
+      floatingActionButton: Column(
+        mainAxisSize: MainAxisSize.min,
+        crossAxisAlignment: CrossAxisAlignment.end,
+        children: [
+          const ResponderToggle(),
+          const SizedBox(height: 16),
+          FloatingActionButton(
+            heroTag: 'add_incident',
+            onPressed: () => _openCreateIncidentForm(),
+            child: const Icon(Icons.add_location_alt),
+          ),
+        ],
       ),
     );
   }

mobile_app/lib/main.dart

@@ -13,6 +13,10 @@ import 'features/map/map_screen.dart';
 import 'features/map/map_service.dart';
 import 'features/prefetch/prefetch_controller.dart';
 import 'services/tile_prefetch_service.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'services/responder_state_service.dart';
+import 'services/location_service.dart';
+import 'controllers/responder_controller.dart';
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
@@ -38,6 +42,16 @@ void main() async {
   );
   final prefetchController = PrefetchController(prefetchService);
 
+  // 4. Responder System
+  final prefs = await SharedPreferences.getInstance();
+  final responderStateService = ResponderStateService(prefs);
+  final locationService = LocationService();
+  final responderController = ResponderController(
+    stateService: responderStateService,
+    locationService: locationService,
+    prefetchService: prefetchService,
+  );
+
   runApp(
     MultiProvider(
       providers: [
@@ -53,6 +67,9 @@ void main() async {
         Provider<TilePrefetchService>.value(value: prefetchService),
         ChangeNotifierProvider<PrefetchController>.value(
             value: prefetchController),
+        Provider<ResponderStateService>.value(value: responderStateService),
+        Provider<LocationService>.value(value: locationService),
+        Provider<ResponderController>.value(value: responderController),
       ],
       child: const OpenRescueApp(),
     ),

mobile_app/lib/services/location_service.dart

@@ -0,0 +1,45 @@
+import 'package:location/location.dart';
+import 'package:latlong2/latlong.dart';
+
+/// Service to handle retrieving device GPS location and managing permissions.
+class LocationService {
+  final Location _location = Location();
+
+  /// Retrieves the current device location.
+  /// Requests permissions and services if necessary.
+  /// Returns [LatLng] if successful, or null if permissions denied or unavailable.
+  Future<LatLng?> getCurrentLocation() async {
+    bool serviceEnabled;
+    PermissionStatus permissionGranted;
+
+    // Check if location services are enabled
+    serviceEnabled = await _location.serviceEnabled();
+    if (!serviceEnabled) {
+      serviceEnabled = await _location.requestService();
+      if (!serviceEnabled) {
+        return null;
+      }
+    }
+
+    // Check if permissions are granted
+    permissionGranted = await _location.hasPermission();
+    if (permissionGranted == PermissionStatus.denied) {
+      permissionGranted = await _location.requestPermission();
+      if (permissionGranted != PermissionStatus.granted) {
+        return null;
+      }
+    }
+
+    // Get the actual location
+    try {
+      final locationData = await _location.getLocation();
+      if (locationData.latitude != null && locationData.longitude != null) {
+        return LatLng(locationData.latitude!, locationData.longitude!);
+      }
+    } catch (e) {
+      // Ignored: fallback to null
+    }
+
+    return null;
+  }
+}

mobile_app/lib/services/responder_state_service.dart

@@ -0,0 +1,63 @@
+import 'dart:async';
+import 'package:flutter/foundation.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+enum ResponderState {
+  inactive,
+  active,
+}
+
+/// Manages responder mode state (inactive / active), persists to SharedPreferences,
+/// and broadcasts changes via an observable Stream.
+class ResponderStateService {
+  static const String _kStateKey = 'responder_state';
+
+  final SharedPreferences _prefs;
+  final _stateController = StreamController<ResponderState>.broadcast();
+
+  ResponderState _currentState = ResponderState.inactive;
+
+  ResponderStateService(this._prefs) {
+    _loadInitialState();
+  }
+
+  /// The current, synchronously available state.
+  ResponderState get currentState => _currentState;
+
+  /// Subscribe to state changes.
+  Stream<ResponderState> get stateStream => _stateController.stream;
+
+  void _loadInitialState() {
+    final active = _prefs.getBool(_kStateKey) ?? false;
+    _currentState = active ? ResponderState.active : ResponderState.inactive;
+    _stateController.add(_currentState);
+  }
+
+  /// Toggle the current responder state.
+  Future<void> toggleState() async {
+    final newState = _currentState == ResponderState.active
+        ? ResponderState.inactive
+        : ResponderState.active;
+
+    await setState(newState);
+  }
+
+  /// Explicitly set the responder state.
+  Future<void> setState(ResponderState newState) async {
+    if (_currentState == newState) return;
+
+    _currentState = newState;
+    await _prefs.setBool(_kStateKey, newState == ResponderState.active);
+
+    if (newState == ResponderState.active) {
+      debugPrint('Responder mode activated');
+    }
+
+    _stateController.add(newState);
+  }
+
+  /// Dispose the stream controller.
+  void dispose() {
+    _stateController.close();
+  }
+}

mobile_app/lib/services/tile_prefetch_service.dart

@@ -11,6 +11,7 @@ import '../core/map/tile_math.dart';
 import '../data/tiles_repository.dart';
 import '../data/db/prefetch_database.dart';
 import '../features/map/map_service.dart';
+import 'package:latlong2/latlong.dart';
 
 /// Progress snapshot for a prefetch job.
 class PrefetchProgress {
@@ -120,6 +121,31 @@ class TilePrefetchService {
     return jobId;
   }
 
+  /// Start a tile prefetch specifically for a geographic radius around [center].
+  /// This bridges domain models [LatLng] with system implementations.
+  Future<String> startPrefetchForRadius(LatLng center, int radiusMeters) async {
+    final jobId = await startJob(
+      lat: center.latitude,
+      lon: center.longitude,
+      radiusMeters: radiusMeters.toDouble(),
+      minZoom: 14,
+      maxZoom: 16,
+      allowLargeJob: true, // Emergency responses might need many tiles
+    );
+
+    // After starting, fetch estimate to fulfill logging requirement
+    final estimate = totalTilesForJob(
+      lat: center.latitude,
+      lon: center.longitude,
+      radiusMeters: radiusMeters.toDouble(),
+      minZoom: 14,
+      maxZoom: 16,
+    );
+    debugPrint('Prefetch queue size: ${estimate.total}');
+    
+    return jobId;
+  }
+
   /// Pause a running job.
   Future<void> pauseJob(String jobId) async {
     _activeJobs[jobId]?.pause();

mobile_app/lib/widgets/responder_toggle.dart

@@ -0,0 +1,38 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import '../services/responder_state_service.dart';
+
+/// FloatingActionButton to toggle between Active and Inactive responder states.
+class ResponderToggle extends StatelessWidget {
+  const ResponderToggle({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Consumer<ResponderStateService>(
+      builder: (context, stateService, child) {
+        return StreamBuilder<ResponderState>(
+          initialData: stateService.currentState,
+          stream: stateService.stateStream,
+          builder: (context, snapshot) {
+            final state = snapshot.data ?? ResponderState.inactive;
+            final isActive = state == ResponderState.active;
+
+            return FloatingActionButton.extended(
+              heroTag: 'responder_toggle',
+              onPressed: () => stateService.toggleState(),
+              backgroundColor: isActive ? Colors.green : Theme.of(context).colorScheme.primary,
+              foregroundColor: Colors.white,
+              icon: Icon(
+                isActive ? Icons.verified_user : Icons.health_and_safety,
+              ),
+              label: Text(
+                isActive ? "Responder Mode Active" : "Become Active Responder",
+                style: const TextStyle(fontWeight: FontWeight.bold),
+              ),
+            );
+          },
+        );
+      },
+    );
+  }
+}

mobile_app/macos/Flutter/GeneratedPluginRegistrant.swift

@@ -6,9 +6,13 @@ import FlutterMacOS
 import Foundation
 
 import flutter_secure_storage_darwin
+import location
+import shared_preferences_foundation
 import sqflite_darwin
 
 func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
   FlutterSecureStorageDarwinPlugin.register(with: registry.registrar(forPlugin: "FlutterSecureStorageDarwinPlugin"))
+  LocationPlugin.register(with: registry.registrar(forPlugin: "LocationPlugin"))
+  SharedPreferencesPlugin.register(with: registry.registrar(forPlugin: "SharedPreferencesPlugin"))
   SqflitePlugin.register(with: registry.registrar(forPlugin: "SqflitePlugin"))
 }