feat(battery): add battery optimization check and settings

sprobst76 · claude · sprobst76 · commit 0907667fff64 · 2026-01-22T06:51:34.000+01:00
Problem: Android kills GeofenceForegroundService due to memory pressure.
When restarting, the service crashes with NullPointerException because
the geofence_foreground_service package doesn't handle null intents.

This causes unreliable geofence tracking - work time "falls out" randomly.

Solution:
- Add REQUEST_IGNORE_BATTERY_OPTIMIZATIONS permission
- Add BatteryOptimizationService to check and request exemption
- Add battery optimization status to Geofence Debug Screen
- Add button to directly open Android settings

Workaround: User should disable battery optimization for VibedTracker
to prevent Android from killing the geofence service.

Co-Authored-By: Claude Opus 4.5 &lt;noreply@anthropic.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,6 +14,22 @@ und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
 
 ---
 
+## [0.1.0-beta.33] - 2026-01-22
+
+### Hinzugefügt
+- **Akkuoptimierung-Check**: Diagnose und Einstellungen im Geofence Debug Screen
+  - Zeigt ob Akkuoptimierung deaktiviert ist (erforderlich für zuverlässiges Geofencing)
+  - Button zum direkten Öffnen der Android-Einstellungen
+  - Erklärt warum der Geofence-Service von Android gekillt werden kann
+
+### Bekanntes Problem (extern)
+- **Geofence Service Crash**: Bug im `geofence_foreground_service` Package
+  - Wenn Android den Service wegen Speicherdruck killt, crasht er beim Neustart
+  - Workaround: Akkuoptimierung für VibedTracker deaktivieren
+  - Issue wurde an Package-Maintainer gemeldet
+
+---
+
 ## [0.1.0-beta.32] - 2026-01-19
 
 ### Hinzugefügt
diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
@@ -20,6 +20,9 @@
     <!-- Wake lock for background processing -->
     <uses-permission android:name="android.permission.WAKE_LOCK"/>
 
+    <!-- Request to ignore battery optimizations (keeps geofence service alive) -->
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
+
     <application
         android:label="VibedTracker"
         android:name="${applicationName}"
diff --git a/android/app/src/main/kotlin/com/vibedtracker/app/MainActivity.kt b/android/app/src/main/kotlin/com/vibedtracker/app/MainActivity.kt
@@ -1,5 +1,51 @@
 package com.vibedtracker.app
 
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.os.PowerManager
+import android.provider.Settings
 import io.flutter.embedding.android.FlutterFragmentActivity
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.plugin.common.MethodChannel
 
-class MainActivity : FlutterFragmentActivity()
+class MainActivity : FlutterFragmentActivity() {
+    private val BATTERY_CHANNEL = "com.vibedtracker.app/battery"
+
+    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
+        super.configureFlutterEngine(flutterEngine)
+
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, BATTERY_CHANNEL).setMethodCallHandler { call, result ->
+            when (call.method) {
+                "isIgnoringBatteryOptimizations" -> {
+                    result.success(isIgnoringBatteryOptimizations())
+                }
+                "requestIgnoreBatteryOptimizations" -> {
+                    requestIgnoreBatteryOptimizations()
+                    result.success(true)
+                }
+                else -> {
+                    result.notImplemented()
+                }
+            }
+        }
+    }
+
+    private fun isIgnoringBatteryOptimizations(): Boolean {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
+            return powerManager.isIgnoringBatteryOptimizations(packageName)
+        }
+        return true // Pre-M doesn't have battery optimization
+    }
+
+    private fun requestIgnoreBatteryOptimizations() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+                data = Uri.parse("package:$packageName")
+            }
+            startActivity(intent)
+        }
+    }
+}
diff --git a/lib/screens/geofence_debug_screen.dart b/lib/screens/geofence_debug_screen.dart
@@ -9,6 +9,7 @@ import '../models/geofence_zone.dart';
 import '../providers.dart';
 import '../services/geofence_event_queue.dart';
 import '../services/geofence_sync_service.dart';
+import '../services/battery_optimization_service.dart';
 import '../models/work_entry.dart';
 import '../theme/theme_colors.dart';
 import 'package:hive/hive.dart';
@@ -26,6 +27,7 @@ class _GeofenceDebugScreenState extends ConsumerState<GeofenceDebugScreen> {
   PermissionStatus? _locationAlwaysPermission;
   PermissionStatus? _notificationPermission;
   bool? _locationServiceEnabled;
+  bool? _batteryOptimizationDisabled;
 
   // Current position
   Position? _currentPosition;
@@ -113,6 +115,7 @@ class _GeofenceDebugScreenState extends ConsumerState<GeofenceDebugScreen> {
       Permission.locationAlways.status,
       Permission.notification.status,
       Geolocator.isLocationServiceEnabled(),
+      BatteryOptimizationService.isIgnoringBatteryOptimizations(),
     ]);
 
     if (mounted) {
@@ -121,6 +124,7 @@ class _GeofenceDebugScreenState extends ConsumerState<GeofenceDebugScreen> {
         _locationAlwaysPermission = results[1] as PermissionStatus;
         _notificationPermission = results[2] as PermissionStatus;
         _locationServiceEnabled = results[3] as bool;
+        _batteryOptimizationDisabled = results[4] as bool;
       });
     }
   }
@@ -302,18 +306,44 @@ class _GeofenceDebugScreenState extends ConsumerState<GeofenceDebugScreen> {
               _locationServiceEnabled == true ? 'Aktiviert' : 'Deaktiviert',
               Icons.gps_fixed,
             ),
+            const Divider(),
+            _buildStatusRow(
+              'Akku-Optimierung',
+              _batteryOptimizationDisabled == true,
+              _batteryOptimizationDisabled == true ? 'Deaktiviert (gut)' : 'Aktiv (problematisch)',
+              Icons.battery_alert,
+            ),
             const SizedBox(height: 12),
             if (_locationAlwaysPermission != PermissionStatus.granted)
+              Padding(
+                padding: const EdgeInsets.only(bottom: 8),
+                child: ElevatedButton.icon(
+                  onPressed: () async {
+                    final status = await Permission.locationAlways.request();
+                    _addLog('Location Always angefordert: $status');
+                    await _loadPermissions();
+                  },
+                  icon: const Icon(Icons.settings),
+                  label: const Text('Location Always anfordern'),
+                  style: ElevatedButton.styleFrom(
+                    backgroundColor: Colors.orange,
+                    foregroundColor: Colors.white,
+                  ),
+                ),
+              ),
+            if (_batteryOptimizationDisabled != true)
               ElevatedButton.icon(
                 onPressed: () async {
-                  final status = await Permission.locationAlways.request();
-                  _addLog('Location Always angefordert: $status');
+                  await BatteryOptimizationService.requestIgnoreBatteryOptimizations();
+                  _addLog('Akkuoptimierung-Einstellungen geöffnet');
+                  // Reload after a delay (user may have changed setting)
+                  await Future.delayed(const Duration(seconds: 2));
                   await _loadPermissions();
                 },
-                icon: const Icon(Icons.settings),
-                label: const Text('Location Always anfordern'),
+                icon: const Icon(Icons.battery_saver),
+                label: const Text('Akkuoptimierung deaktivieren'),
                 style: ElevatedButton.styleFrom(
-                  backgroundColor: Colors.orange,
+                  backgroundColor: Colors.red,
                   foregroundColor: Colors.white,
                 ),
               ),
diff --git a/lib/services/battery_optimization_service.dart b/lib/services/battery_optimization_service.dart
@@ -0,0 +1,98 @@
+import 'dart:io';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+
+/// Service to handle battery optimization settings for reliable background geofencing.
+///
+/// When Android's battery optimization is enabled for an app, the system may:
+/// - Kill background services during memory pressure
+/// - Delay or skip scheduled work
+/// - Throttle location updates
+///
+/// This service helps the user disable battery optimization for VibedTracker
+/// to ensure reliable geofence detection.
+class BatteryOptimizationService {
+  static const platform = MethodChannel('com.vibedtracker.app/battery');
+
+  /// Checks if battery optimization is currently disabled for the app.
+  /// Returns true if the app is whitelisted (optimization disabled).
+  static Future<bool> isIgnoringBatteryOptimizations() async {
+    if (!Platform.isAndroid) return true;
+
+    try {
+      final result = await platform.invokeMethod<bool>('isIgnoringBatteryOptimizations');
+      return result ?? false;
+    } on PlatformException catch (e) {
+      debugPrint('Error checking battery optimization: ${e.message}');
+      return false;
+    } on MissingPluginException {
+      debugPrint('Battery optimization plugin not available');
+      return true; // Assume OK if plugin not available
+    }
+  }
+
+  /// Opens the system settings to disable battery optimization for this app.
+  static Future<bool> requestIgnoreBatteryOptimizations() async {
+    if (!Platform.isAndroid) return true;
+
+    try {
+      final result = await platform.invokeMethod<bool>('requestIgnoreBatteryOptimizations');
+      return result ?? false;
+    } on PlatformException catch (e) {
+      debugPrint('Error requesting battery optimization exemption: ${e.message}');
+      return false;
+    } on MissingPluginException {
+      debugPrint('Battery optimization plugin not available');
+      return false;
+    }
+  }
+
+  /// Shows a dialog explaining why battery optimization should be disabled
+  /// and offers to open the settings.
+  static Future<void> showOptimizationDialog(BuildContext context) async {
+    final isIgnoring = await isIgnoringBatteryOptimizations();
+
+    if (isIgnoring) {
+      debugPrint('Battery optimization already disabled');
+      return;
+    }
+
+    if (!context.mounted) return;
+
+    await showDialog<void>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Akkuoptimierung deaktivieren'),
+        content: const Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Text(
+              'Für zuverlässige automatische Zeiterfassung muss die '
+              'Akkuoptimierung für VibedTracker deaktiviert werden.',
+            ),
+            SizedBox(height: 12),
+            Text(
+              'Ohne diese Einstellung kann Android den Geofence-Service '
+              'beenden und die Arbeitszeit wird nicht korrekt erfasst.',
+              style: TextStyle(fontSize: 13, color: Colors.grey),
+            ),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Später'),
+          ),
+          FilledButton(
+            onPressed: () async {
+              Navigator.pop(context);
+              await requestIgnoreBatteryOptimizations();
+            },
+            child: const Text('Einstellungen öffnen'),
+          ),
+        ],
+      ),
+    );
+  }
+}
diff --git a/pubspec.yaml b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: time_tracker
 description: Zeiterfassung mit Geofence, Urlaub, Feiertagen & ICS-Sync
-version: 0.1.0-beta.32+32
+version: 0.1.0-beta.33+33
 publish_to: 'none'
 
 environment:
