screen crashing

[CarlosChato]

Hi i have the following flutter screen which i use foregorund activity for calculating the risk between two elements, the screen and the app is working fine on the android emulator ( using android studio and flutter run on the terminal) but when i generate the apk and i install it into my phone, that screen crash o for example the second one, when i init the fore gorund service:

import 'dart:async';
import 'dart:io';

import 'package:bip_application/controller/notification_controller.dart';
import 'package:bip_application/services/location_service.dart';
import 'package:bip_application/services/risk_calculation_service.dart';
import 'package:bip_application/tools/blinking_risk_alert.dart';
import 'package:bip_application/tools/defualt_appbar.dart';
import 'package:bip_application/tools/secure_storage.dart';
import 'package:bip_application/tools/ws_handler.dart';
import 'package:flutter/material.dart';
import 'package:flutter_foreground_task/flutter_foreground_task.dart';
import 'package:geolocator/geolocator.dart';

class BIPHome extends StatefulWidget {
  const BIPHome({super.key});

  @override
  State<BIPHome> createState() => _BIPHomeState();
}

class _BIPHomeState extends State<BIPHome> {
  final _secureStorage = SecureStorage();
  final _locationService = LocationService();

  late final WebSocketManager _socketManager;
  late final NotificationController _notificationController;

  Position? _currentPosition;
  String? _errorMessage;
  StreamSubscription<Position>?
      _positionSubscription; // 🔹 Suscripción manejada correctamente

  RiskLevel _currentRiskLevel = RiskLevel.none;
  Position? _otherPosition;

  @override
  void initState() {
    super.initState();
    _requestPermissions();
    _socketManager = WebSocketManager(
        url: "ws://10.0.2.2:8080/coordinates",
        onPositionReceived: _updateOtherPosition);
    _notificationController = NotificationController();
    _initService();
    _startForegroundService();
    _initializeServices();
  }

  void _updateOtherPosition(double latitude, double longitude) {
    _otherPosition = Position(
      latitude: latitude,
      longitude: longitude,
      timestamp: DateTime.now(),
      accuracy: 0,
      altitude: 0,
      heading: 0,
      speed: 0,
      speedAccuracy: 0,
      altitudeAccuracy: 0,
      headingAccuracy: 0,
    );
    _evaluateRiskLevel();
  }

  void _evaluateRiskLevel() {
    if (_currentPosition != null && _otherPosition != null) {
      final newRiskLevel =
          RiskManager.calculateRiskLevel(_currentPosition!, _otherPosition!);

      if (newRiskLevel != _currentRiskLevel && mounted) {
        // 🔹 Verificación de mounted
        setState(() {
          _currentRiskLevel = newRiskLevel;
        });

        // Send notification if app is in the background
        _notificationController.showSystemNotification(_currentRiskLevel);
      }
    }
  }

  void _startForegroundService() {
    FlutterForegroundTask.startService(
      notificationTitle: 'Risk Monitoring',
      notificationText: 'Monitoring your risk level...',
      callback: () {
        if (mounted) _evaluateRiskLevel();
      },
    );
  }

  void _initLocationPermissions() async {
    bool hasPermissions = await _locationService.checkAndRequestPermissions();

    if (!hasPermissions && mounted) {
      setState(() {
        _errorMessage =
            "Los permisos de localización son requeridos, por favor actívalos en ajustes";
      });
    }
  }

  Future<void> _initializeServices() async {
    _initLocationPermissions();

    await _notificationController.init();

    _socketManager.connect();

    _currentPosition = await _locationService.getCurrentPosition();
    if (mounted) {
      setState(() {}); // 🔹 Refrescar solo si el widget sigue montado
    }

    _positionSubscription = _locationService.getPositionStream().listen(
      (Position position) {
        _currentPosition = position;
        if (mounted) {
          setState(() {}); // 🔹 Verificar que el widget sigue en el árbol
          _evaluateRiskLevel();
        }
      },
      onError: (error) {
        if (mounted) {
          setState(() {
            _errorMessage = "Error fetching location: $error";
          });
        }
      },
    );
  }

  Future<void> _requestPermissions() async {
    // Permiso para mostrar notificaciones
    final NotificationPermission notificationPermission =
        await FlutterForegroundTask.checkNotificationPermission();
    if (notificationPermission != NotificationPermission.granted) {
      print("Solicitando permiso de notificaciones...");
      await FlutterForegroundTask.requestNotificationPermission();
    }

    if (Platform.isAndroid) {
      // Ignorar optimización de batería
      bool isIgnoringBatteryOptimizations =
          await FlutterForegroundTask.isIgnoringBatteryOptimizations;
      if (!isIgnoringBatteryOptimizations) {
        print("Solicitando permiso para ignorar optimización de batería...");
        await FlutterForegroundTask.requestIgnoreBatteryOptimization();
      }

      // Permiso para alarmas exactas (necesario en Android 12+)
      bool canScheduleExactAlarms =
          await FlutterForegroundTask.canScheduleExactAlarms;
      if (!canScheduleExactAlarms) {
        print("Solicitando permiso para alarmas exactas...");
        await FlutterForegroundTask.openAlarmsAndRemindersSettings();
      }
    }
  }

  void _initService() {
    FlutterForegroundTask.init(
      androidNotificationOptions: AndroidNotificationOptions(
        channelId: 'foreground_service',
        channelName: 'Foreground Service Notification',
        channelDescription:
            'This notification appears when the foreground service is running.',
        onlyAlertOnce: true,
      ),
      iosNotificationOptions: const IOSNotificationOptions(
        showNotification: false,
        playSound: false,
      ),
      foregroundTaskOptions: ForegroundTaskOptions(
        eventAction: ForegroundTaskEventAction.repeat(5000),
        autoRunOnBoot: true,
        autoRunOnMyPackageReplaced: true,
        allowWakeLock: true,
        allowWifiLock: true,
      ),
    );
  }

  @override
  void dispose() {
    _socketManager.disconnect();
    _positionSubscription?.cancel(); // 🔹 Cancelar la suscripción al stream
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: CustomAppBar(
        title: "Home",
        actions: [
          IconButton(
              onPressed: () {
                _secureStorage.deleteData("isLogged");
                Navigator.pushReplacementNamed(context, "/");
              },
              icon: const Icon(Icons.logout))
        ],
      ),
      body: _errorMessage == null
          ? (_currentPosition != null
              ? BlinkingRiskAlert(riskLevel: _currentRiskLevel)
              : const Center(
                  child: Text("Obteniendo posición..."),
                ))
          : Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                Text(
                  _errorMessage!,
                  textAlign: TextAlign.center,
                  style: const TextStyle(fontSize: 18, color: Colors.red),
                ),
                const SizedBox(height: 20),
                ElevatedButton(
                  onPressed: _initializeServices,
                  child: const Text("Try Again"),
                ),
              ],
            ),
    );
  }
}

Or this other one:

import 'dart:io';

// import 'package:bip_application/services/location_sender_service.dart';
import 'package:bip_application/tools/defualt_appbar.dart';
import 'package:bip_application/tools/secure_storage.dart';
import 'package:bip_application/tools/sender_background_task_handler.dart';
import 'package:flutter/material.dart';
import 'package:flutter_foreground_task/flutter_foreground_task.dart';

class HomeEmergency extends StatefulWidget {
  const HomeEmergency({super.key});

  @override
  State<HomeEmergency> createState() => _HomeEmergencyState();
}

class _HomeEmergencyState extends State<HomeEmergency> {
  final _secureStorage = SecureStorage();
  bool _isTracking = false;
  // final LocationSenderService _locationSenderService = LocationSenderService();

  @override
  void initState() {
    super.initState();
    _requestPermissions();
    _initService();
    _checkTrackingStatus();
  }

  // Verifica si el servicio de seguimiento está en ejecución
  Future<void> _checkTrackingStatus() async {
    bool isRunning = await FlutterForegroundTask.isRunningService;
    setState(() {
      _isTracking = isRunning;
    });
  }

  // Inicia o detiene el seguimiento dependiendo del estado
  void _toggleLocationTracking() {
    if (_isTracking) {
      _stopBackgroundTask();
    } else {
      _startBackgroundTask();
    }

    setState(() {
      _isTracking = !_isTracking;
    });
  }

  // Inicia el servicio en segundo plano
  void _startBackgroundTask() async {
    bool running = await FlutterForegroundTask.isRunningService;
    print("¿Está corriendo el servicio? $running");
    if (!running) {
      print("Iniciando el servicio en segundo plano...");
      await FlutterForegroundTask.startService(
        notificationTitle: 'Tracking Location',
        notificationText: 'Enviando ubicación en segundo plano',
        callback: startCallback,
      );
      print("Servicio de ubicación iniciado.");
    } else {
      print("El servicio ya está corriendo.");
    }
  }

  // Detiene el servicio en segundo plano
  void _stopBackgroundTask() async {
    await FlutterForegroundTask.stopService();
    print("Servicio de ubicación detenido.");
  }

  Future<void> _requestPermissions() async {
    final NotificationPermission notificationPermission =
        await FlutterForegroundTask.checkNotificationPermission();

    if (notificationPermission != NotificationPermission.granted) {
      await FlutterForegroundTask.requestNotificationPermission();
    }

    if (Platform.isAndroid) {
      // Ignorar optimización de batería solo si no está ignorada ya
      bool isIgnoringBatteryOptimizations =
          await FlutterForegroundTask.isIgnoringBatteryOptimizations;
      if (!isIgnoringBatteryOptimizations) {
        await FlutterForegroundTask.requestIgnoreBatteryOptimization();
      }

      // Permisos de alarmas exactas solo si no están habilitados
      bool canScheduleExactAlarms =
          await FlutterForegroundTask.canScheduleExactAlarms;
      if (!canScheduleExactAlarms) {
        await FlutterForegroundTask.openAlarmsAndRemindersSettings();
      }
    }
  }

  void _initService() {
    FlutterForegroundTask.init(
      androidNotificationOptions: AndroidNotificationOptions(
        channelId: 'foreground_service',
        channelName: 'Foreground Service Notification',
        channelDescription:
            'This notification appears when the foreground service is running.',
        onlyAlertOnce: true,
      ),
      iosNotificationOptions: const IOSNotificationOptions(
        showNotification: false,
        playSound: false,
      ),
      foregroundTaskOptions: ForegroundTaskOptions(
        eventAction: ForegroundTaskEventAction.repeat(5000),
        autoRunOnBoot: true,
        autoRunOnMyPackageReplaced: true,
        allowWakeLock: true,
        allowWifiLock: true,
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: CustomAppBar(
        title: "BIP Emergency Home",
        actions: [
          IconButton(
            onPressed: () {
              _secureStorage.deleteData("isLogged");
              Navigator.pushReplacementNamed(context, "/");
            },
            icon: const Icon(Icons.logout),
          ),
        ],
      ),
      body: Padding(
        padding: const EdgeInsets.all(15),
        child: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              const Text("Emergency"),
              const SizedBox(height: 20),
              ElevatedButton(
                onPressed: _toggleLocationTracking,
                child: Text(_isTracking
                    ? "Detener Seguimiento"
                    : "Iniciar Seguimiento"),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

which use this controller:

import 'dart:async';
import 'package:flutter_foreground_task/flutter_foreground_task.dart';
import 'package:geolocator/geolocator.dart';
import 'package:bip_application/services/location_sender_service.dart';
import 'package:bip_application/services/location_service.dart';

@pragma('vm:entry-point')
void startCallback() {
  print("startCallback llamado");
  FlutterForegroundTask.setTaskHandler(BackgroundTaskHandler());
}

class BackgroundTaskHandler extends TaskHandler {
  final LocationSenderService _locationSenderService = LocationSenderService();
  StreamSubscription<Position>? _positionSubscription;

  @override
  Future<void> onStart(DateTime timestamp, TaskStarter starter) async {
    print("Servicio en segundo plano iniciado con starter: ${starter.name}");

    final locationService = LocationService();
    bool hasPermission = await locationService.checkAndRequestPermissions();

    if (!hasPermission) {
      print("No hay permisos de ubicación.");
      return;
    }

    _positionSubscription = locationService.getPositionStream().listen(
      (Position position) {
        print(
            "Ubicación obtenida: ${position.latitude}, ${position.longitude}");
        _locationSenderService.sendLocation(position);
      },
    );
  }

  @override
  void onRepeatEvent(DateTime timestamp) {
    print("Evento repetitivo en segundo plano.");
  }

  @override
  Future<void> onDestroy(DateTime timestamp) async {
    _positionSubscription?.cancel();
    _positionSubscription = null;
    print("Servicio en segundo plano detenido.");
  }

  @override
  void onReceiveData(Object data) {
    print("Datos recibidos en segundo plano: $data");
  }

  @override
  void onNotificationPressed() {
    print("Notificación de servicio en segundo plano presionada.");
  }

  @override
  void onNotificationButtonPressed(String id) {
    print("Botón de notificación presionado: $id");
  }

  @override
  void onNotificationDismissed() {
    print("Notificación descartada.");
  }
}

Any ideas about what is causing the crash and how to fix it. Thanks so much :D