calculateSettings method

Implementation

AdaptiveSettings calculateSettings({
  required double speedMps,
  required int batteryPercent,
  required bool isCharging,
  required bool isMoving,
  required ActivityType? activity,
  required bool isInGeofence,
  Duration? timeSinceStationary,
}) {
  // When charging, use high performance settings
  if (isCharging) {
    return const AdaptiveSettings(
      distanceFilter: 10,
      desiredAccuracy: DesiredAccuracy.high,
      heartbeatInterval: 60,
      gpsEnabled: true,
      reason: 'Charging - high performance mode',
    );
  }

  // Low battery mode
  final batteryLevel = batteryThresholds.getLevel(batteryPercent);
  if (batteryLevel == BatteryLevel.critical) {
    return const AdaptiveSettings(
      distanceFilter: 200,
      desiredAccuracy: DesiredAccuracy.low,
      heartbeatInterval: 900, // 15 minutes
      gpsEnabled: false,
      reason: 'Critical battery - minimal tracking',
    );
  }

  if (batteryLevel == BatteryLevel.low) {
    return AdaptiveSettings(
      distanceFilter: 100,
      desiredAccuracy: DesiredAccuracy.medium,
      heartbeatInterval: smartHeartbeat ? 300 : 120,
      gpsEnabled: isMoving,
      reason: 'Low battery - reduced tracking',
    );
  }

  // Stationary optimization - with stationaryDelay check
  if (!isMoving && stationaryGpsOff) {
    // Only disable GPS after stationaryDelay has passed
    final hasExceededDelay =
        timeSinceStationary == null || timeSinceStationary >= stationaryDelay;

    if (hasExceededDelay) {
      final heartbeat = smartHeartbeat
          ? maxHeartbeatInterval.inSeconds
          : minHeartbeatInterval.inSeconds;
      return AdaptiveSettings(
        distanceFilter: 50,
        desiredAccuracy: DesiredAccuracy.low,
        heartbeatInterval: heartbeat,
        gpsEnabled: false,
        reason: 'Stationary (${stationaryDelay.inSeconds}s) - GPS disabled',
      );
    }
  }

  // Activity-based optimization (when enabled)
  if (activityOptimization && activity != null) {
    final activitySettings = _getActivityBasedSettings(activity, speedMps);
    if (activitySettings != null) {
      return activitySettings;
    }
  }

  // Geofence optimization
  if (isInGeofence && geofenceOptimization && !isMoving) {
    return AdaptiveSettings(
      distanceFilter: 25,
      desiredAccuracy: DesiredAccuracy.medium,
      heartbeatInterval: 180,
      gpsEnabled: true,
      reason: 'In geofence - reduced accuracy',
    );
  }

  // Speed-based optimization (fallback)
  final speedKph = speedMps * 3.6;
  final tier = speedTiers.getTier(speedKph);

  return AdaptiveSettings(
    distanceFilter: tier.distanceFilter.toDouble(),
    desiredAccuracy: tier.accuracy,
    heartbeatInterval: tier.updateInterval,
    gpsEnabled: true,
    reason: 'Speed-based: ${tier.name}',
  );
}