Merge remote-tracking branch 'origin/dev' into gps-toggle-in-settings

# Conflicts:
#	lib/l10n/app_bg.arb
#	lib/l10n/app_de.arb
#	lib/l10n/app_es.arb
#	lib/l10n/app_fr.arb
#	lib/l10n/app_hu.arb
#	lib/l10n/app_it.arb
#	lib/l10n/app_ja.arb
#	lib/l10n/app_ko.arb
#	lib/l10n/app_localizations_es.dart
#	lib/l10n/app_localizations_it.dart
#	lib/l10n/app_localizations_nl.dart
#	lib/l10n/app_localizations_pt.dart
#	lib/l10n/app_localizations_sv.dart
#	lib/l10n/app_localizations_uk.dart
#	lib/l10n/app_nl.arb
#	lib/l10n/app_pl.arb
#	lib/l10n/app_pt.arb
#	lib/l10n/app_ru.arb
#	lib/l10n/app_sk.arb
#	lib/l10n/app_sl.arb
#	lib/l10n/app_sv.arb
#	lib/l10n/app_uk.arb
#	lib/l10n/app_zh.arb

lib/services/background_service.dart

@@ -1,8 +1,19 @@
-import '../utils/platform_info.dart';
+import 'package:flutter/widgets.dart';
 import 'package:flutter_foreground_task/flutter_foreground_task.dart';
 
+import '../l10n/app_localizations.dart';
+import '../utils/platform_info.dart';
+
 class BackgroundService {
   bool _initialized = false;
+  String? Function()? _languageOverrideProvider;
+
+  /// Allows the app to expose its current language override (e.g. from
+  /// AppSettingsService) so the foreground notification matches the app UI
+  /// language instead of only the system locale.
+  void setLanguageOverrideProvider(String? Function()? provider) {
+    _languageOverrideProvider = provider;
+  }
 
   Future<void> initialize() async {
     if (!PlatformInfo.isAndroid || _initialized) return;
@@ -34,13 +45,31 @@ class BackgroundService {
     }
     final running = await FlutterForegroundTask.isRunningService;
     if (running) return;
+    final l10n = await _loadLocalizations();
     await FlutterForegroundTask.startService(
-      notificationTitle: 'MeshCore running',
-      notificationText: 'Keeping BLE connected',
+      notificationTitle: l10n.background_serviceTitle,
+      notificationText: l10n.background_serviceText,
       callback: startCallback,
     );
   }
 
+  Future<AppLocalizations> _loadLocalizations() async {
+    final supported = AppLocalizations.supportedLocales;
+    final override = _languageOverrideProvider?.call();
+    if (override != null && override.isNotEmpty) {
+      final overrideLocale = Locale(override);
+      final isSupported = supported.any(
+        (l) => l.languageCode == overrideLocale.languageCode,
+      );
+      if (isSupported) {
+        return AppLocalizations.delegate.load(overrideLocale);
+      }
+    }
+    final preferred = WidgetsBinding.instance.platformDispatcher.locales;
+    final match = basicLocaleListResolution(preferred, supported);
+    return AppLocalizations.delegate.load(match);
+  }
+
   Future<void> stop() async {
     if (!PlatformInfo.isAndroid) return;
     final running = await FlutterForegroundTask.isRunningService;

lib/services/line_of_sight_service.dart

@@ -24,6 +24,26 @@ class LineOfSightSample {
   });
 }
 
+class LineOfSightObstruction {
+  final int sampleIndex;
+  final LatLng point;
+  final double distanceMeters;
+  final double clearanceMeters;
+  final double obstructionMeters;
+  final double terrainMeters;
+  final double lineHeightMeters;
+
+  const LineOfSightObstruction({
+    required this.sampleIndex,
+    required this.point,
+    required this.distanceMeters,
+    required this.clearanceMeters,
+    required this.obstructionMeters,
+    required this.terrainMeters,
+    required this.lineHeightMeters,
+  });
+}
+
 class LineOfSightResult {
   final bool hasData;
   final bool isClear;
@@ -31,6 +51,7 @@ class LineOfSightResult {
   final double maxObstructionMeters;
   final double? firstObstructionDistanceMeters;
   final List<LineOfSightSample> samples;
+  final List<LineOfSightObstruction> obstructions;
   final String? errorMessage;
   final double usedKFactor;
   final double? frequencyMHz;
@@ -42,6 +63,7 @@ class LineOfSightResult {
     required this.maxObstructionMeters,
     required this.firstObstructionDistanceMeters,
     required this.samples,
+    required this.obstructions,
     required this.usedKFactor,
     this.frequencyMHz,
     this.errorMessage,
@@ -56,7 +78,8 @@ class LineOfSightResult {
        isClear = false,
        maxObstructionMeters = 0,
        firstObstructionDistanceMeters = null,
-       samples = const [];
+       samples = const [],
+       obstructions = const [];
 }
 
 class LineOfSightPathSegment {
@@ -191,6 +214,7 @@ class LineOfSightService {
         maxObstructionMeters: 0,
         firstObstructionDistanceMeters: null,
         samples: const [],
+        obstructions: const [],
         usedKFactor: kFactor,
         frequencyMHz: frequencyMHz,
       );
@@ -249,7 +273,9 @@ class LineOfSightService {
     var maxObstructionMeters = 0.0;
     double? firstObstructionDistanceMeters;
     final samples = <LineOfSightSample>[];
+    final obstructions = <LineOfSightObstruction>[];
     var isClear = true;
+    LineOfSightObstruction? clusterWorstObstruction;
 
     for (int i = 0; i < points.length; i++) {
       final fraction = points.length == 1 ? 0.0 : i / (points.length - 1);
@@ -274,6 +300,23 @@ class LineOfSightService {
           maxObstructionMeters = obstruction;
         }
         firstObstructionDistanceMeters ??= distanceFromStart;
+        final candidate = LineOfSightObstruction(
+          sampleIndex: i,
+          point: points[i],
+          distanceMeters: distanceFromStart,
+          clearanceMeters: clearance,
+          obstructionMeters: obstruction,
+          terrainMeters: terrainHeight,
+          lineHeightMeters: lineHeight,
+        );
+        if (clusterWorstObstruction == null ||
+            candidate.obstructionMeters >
+                clusterWorstObstruction.obstructionMeters) {
+          clusterWorstObstruction = candidate;
+        }
+      } else if (clusterWorstObstruction != null) {
+        obstructions.add(clusterWorstObstruction);
+        clusterWorstObstruction = null;
       }
 
       samples.add(
@@ -286,6 +329,9 @@ class LineOfSightService {
         ),
       );
     }
+    if (clusterWorstObstruction != null) {
+      obstructions.add(clusterWorstObstruction);
+    }
 
     return LineOfSightResult(
       hasData: true,
@@ -294,6 +340,7 @@ class LineOfSightService {
       maxObstructionMeters: maxObstructionMeters,
       firstObstructionDistanceMeters: firstObstructionDistanceMeters,
       samples: samples,
+      obstructions: obstructions,
       usedKFactor: kFactor,
       frequencyMHz: frequencyMHz,
     );

lib/services/translation_service.dart

@@ -519,12 +519,11 @@ class TranslationService extends ChangeNotifier {
   }
 
   String? _heuristicLanguageCode(String text) {
-    if (RegExp(r'[іїєґІЇЄҐ]').hasMatch(text)) {
-      return 'uk';
-    }
-    if (RegExp(r'[а-яёА-ЯЁ]').hasMatch(text)) {
-      return 'ru';
+    final trimmed = text.trim();
+    if (trimmed.isEmpty) {
+      return null;
     }
+
     if (RegExp(r'[ぁ-んァ-ン]').hasMatch(text)) {
       return 'ja';
     }
@@ -534,9 +533,55 @@ class TranslationService extends ChangeNotifier {
     if (RegExp(r'[\u4e00-\u9fff]').hasMatch(text)) {
       return 'zh';
     }
-    // Latin-script languages can't be reliably distinguished by characters
-    // alone — return null so the translator always attempts translation.
-    return null;
+
+    final lower = trimmed.toLowerCase();
+    final patterns = <String, String>{
+      'uk': r'\b(привіт|дякую|будь|ласка|як|де|не|так|це|є|най|ще|може|для)\b',
+      'ru':
+          r'\b(что|это|как|не|да|нет|он|она|они|быть|есть|для|сегодня|если|уже|может)\b',
+      'bg': r'\b(ще|няма|благодаря|моля|това|какво|тук|ние|вие|не|със|за)\b',
+      'de':
+          r'\b(der|die|das|und|ist|nicht|ein|eine|ich|für|mit|auf|zu|auch|als|an|im|am|es|dem|den|sich|von)\b',
+      'en':
+          r'\b(the|and|is|you|for|with|from|not|that|this|have|be|are|was|were|but|can|will|your|what|when|how|they)\b',
+      'es':
+          r'\b(el|la|los|las|es|que|de|en|con|por|para|no|un|una|se|como|su|al|del|está)\b',
+      'fr':
+          r'\b(le|la|les|un|une|et|est|que|qui|pour|dans|pas|avec|sur|ne|vous|il|elle|des|ce|cette|je|tu|nous|vous)\b',
+      'it':
+          r'\b(il|la|lo|un|una|che|di|da|in|per|con|non|si|mi|ti|noi|voi|lui|lei)\b',
+      'pt':
+          r'\b(os|as|que|de|do|da|em|para|com|por|não|uma|um|se|você|também)\b',
+      'nl':
+          r'\b(de|het|een|en|is|niet|dat|wat|je|ik|op|aan|voor|met|als|nog|zijn)\b',
+      'sv':
+          r'\b(och|är|det|att|som|en|på|inte|har|var|men|du|jag|vi|ni|den|detta)\b',
+      'pl':
+          r'\b(na|się|nie|jest|to|że|do|od|dla|czy|tak|ale|ma|jak|on|ona|my)\b',
+      'sk': r'\b(je|na|so|že|do|od|za|si|to|ten|tá|tí|ako|má|nie|som|sa)\b',
+      'sl': r'\b(in|je|na|se|da|za|od|ne|to|ta|so|kako|bo|sem|si)\b',
+      'hu':
+          r'\b(az|és|nem|van|volt|hogy|mit|mire|ki|mi|ez|azért|is|de|ha|te|ő|mi|itt)\b',
+    };
+
+    final scores = <String, int>{};
+    for (final entry in patterns.entries) {
+      scores[entry.key] = RegExp(
+        entry.value,
+        caseSensitive: false,
+      ).allMatches(lower).length;
+    }
+
+    final sorted = scores.entries.toList()
+      ..sort((a, b) => b.value.compareTo(a.value));
+    if (sorted.isEmpty || sorted.first.value == 0) {
+      return null;
+    }
+    if (sorted.length > 1 && sorted.first.value == sorted[1].value) {
+      return null;
+    }
+
+    return sorted.first.key;
   }
 
   String _languageLabel(String code) {