'onRepeatEvent' stops working after several hours in the background. #350

 // code ... 
 FlutterForegroundTask.initCommunicationPort();
 runApp(App());

@pragma('vm:entry-point')
void startCallback() {
  FlutterForegroundTask.setTaskHandler(BackgroundHandler());
}

class BackgroundHandler extends TaskHandler {
  final _translationService = _getTranslations();

  static Map<String, String> _getTranslations() {
    final language = UserPreferences.getDefaultLanguage();
    return getTranslationService(language: language);
  }

@override
  Future<void> onStart(DateTime timestamp, TaskStarter starter) async {
    final time = DateHelper.getTime(timestamp.millisecondsSinceEpoch);
    log('onStart(time: $time, starter: ${starter.name})');

    _updateNotification();
  }

  @override
  void onRepeatEvent(DateTime timestamp) {
    final time = DateHelper.getTime(timestamp.millisecondsSinceEpoch);
    log('onRepeatEvent(time: $time)');
    _updateNotification();
    // code ...
  }

  @override
  Future<void> onDestroy(DateTime timestamp, bool isTimeout) async {
    final time = DateHelper.getTime(timestamp.millisecondsSinceEpoch);
    log('onDestroy(time: $time, isTimeout: $isTimeout)');
  }

  @override
  void onReceiveData(Object data) {
    log('onReceiveData(data: $data)');
  }

  @override
  void onNotificationButtonPressed(String id) {
    log('onNotificationButtonPressed(id: $id)');
  }

  @override
  void onNotificationPressed() {
    log('onNotificationPressed()');
  }

  @override
  void onNotificationDismissed() {
    log('onNotificationDismissed()');
  }

  Future<void> _updateNotification() async {
    await FlutterForegroundTask.updateService(
      notificationTitle: _translationService['service_title'] ?? '',
      notificationText: _translationService['service_description'] ?? '',
    );
  }
}

class BackgroundService {
  static final _translationService = getTranslations();
  static bool _hasLocation = false;

  static Map<String, String> getTranslations() {
    final language = UserPreferences.getDefaultLanguage();

    return getTranslationService(language: language);
  }

  static Future<bool> isRunningBackgroundService() async {
    final isRunning = await FlutterForegroundTask.isRunningService;
    return isRunning;
  }

  static Future<void> requestBackgroundPermissions() async {
    final NotificationPermission notificationPermission =
        await FlutterForegroundTask.checkNotificationPermission();
    if (notificationPermission != NotificationPermission.granted) {
      await FlutterForegroundTask.requestNotificationPermission();
    }

    if (isAndroid) {
      if (!await FlutterForegroundTask.isIgnoringBatteryOptimizations) {
        await FlutterForegroundTask.requestIgnoreBatteryOptimization();
      }

      if (!await FlutterForegroundTask.canScheduleExactAlarms) {
        await FlutterForegroundTask.openAlarmsAndRemindersSettings();
      }
    }
  }

  static Future<void> initService() async {
    FlutterForegroundTask.init(
      androidNotificationOptions: AndroidNotificationOptions(
        channelId: BACKGROUND_SERVICE_CHANNEL_ID,
        channelName: _translationService['service_channel_name'] ?? '',
        channelDescription: _translationService['service_channel_description'],
        onlyAlertOnce: true,
      ),
      iosNotificationOptions: const IOSNotificationOptions(
        showNotification: false,
      ),
      foregroundTaskOptions: ForegroundTaskOptions(
        eventAction: ForegroundTaskEventAction.repeat(5000),
        autoRunOnBoot: true,
        autoRunOnMyPackageReplaced: true,
        allowWifiLock: true,
        allowWakeLock: true,
      ),
    );
  }

  static Future<ServiceRequestResult> startBackgroundService({
    required bool hasLocation,
  }) async {
    _hasLocation = hasLocation;

    if (await FlutterForegroundTask.isRunningService) {
      return FlutterForegroundTask.restartService();
    } else {
      final serviceTypes = [
        ForegroundServiceTypes.dataSync,
        ForegroundServiceTypes.remoteMessaging,
      ];

      if (_hasLocation) {
        serviceTypes.add(ForegroundServiceTypes.location);
      }

      return FlutterForegroundTask.startService(
        serviceId: BACKGROUND_SERVICE_NOTIFICATION_ID,
        notificationTitle: _translationService['service_title'] ?? '',
        notificationText: _translationService['service_description'] ?? '',
        serviceTypes: serviceTypes,
        notificationInitialRoute: '/',
        callback: startCallback,
      );
    }
  }

  static Future<ServiceRequestResult> stopBackgroundService() async {
    // code ...
    return FlutterForegroundTask.stopService();
  }
}