devibe changelog

assets/changelog.json

@@ -1,9 +1,14 @@
 {
+  "2.10.1": {
+    "content": [
+      "• Operator profiles are now reorderable",
+      "• Support operator profile import via deflockapp:// links",
+      "• Makes operator profile UI consistent with device profiles"
+    ]
+  },
   "2.10.0": {
     "content": [
-      "• Simplified profile field-of-view settings - profiles now use a simple '360 FOV' checkbox instead of custom degree values",
-      "• Existing profiles with non-360° FOV settings have been automatically updated to use default cone angles",
-      "• All existing functionality for reading and displaying surveillance devices with custom FOV ranges is preserved"
+      "• Simplified profile FOVs; there is now only a checkbox for '360'",
     ]
   },
   "2.9.2": {

lib/app_state.dart

@@ -442,6 +442,10 @@ class AppState extends ChangeNotifier {
     _operatorProfileState.deleteProfile(p);
   }
 
+  void reorderOperatorProfiles(int oldIndex, int newIndex) {
+    _operatorProfileState.reorderProfiles(oldIndex, newIndex);
+  }
+
   // ---------- Session Methods ----------
   void startAddSession() {
     _sessionState.startAddSession(enabledProfiles);

lib/localizations/de.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Versorgungsgenehmigungsdaten, die auf potenzielle Installationsstandorte für Überwachungsinfrastruktur hinweisen",
     "dataSourceCredit": "Datensammlung und -hosting bereitgestellt von alprwatch.org",
     "minimumDistance": "Mindestabstand zu echten Geräten",
-    "minimumDistanceSubtitle": "Verdächtige Standorte innerhalb von {}m vorhandener Überwachungsgeräte ausblenden",
+    "minimumDistanceSubtitle": "Verdächtige Standorte innerhalb von {} vorhandener Überwachungsgeräte ausblenden",
     "updating": "Verdächtige Standorte werden aktualisiert",
     "downloadingAndProcessing": "Daten werden heruntergeladen und verarbeitet...",
     "updateSuccess": "Verdächtige Standorte erfolgreich aktualisiert",

lib/localizations/en.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Utility permit data indicating potential surveillance infrastructure installation sites",
     "dataSourceCredit": "Data collection and hosting provided by alprwatch.org",
     "minimumDistance": "Minimum Distance from Real Nodes",
-    "minimumDistanceSubtitle": "Hide suspected locations within {}m of existing surveillance devices",
+    "minimumDistanceSubtitle": "Hide suspected locations within {} of existing surveillance devices",
     "updating": "Updating Suspected Locations",
     "downloadingAndProcessing": "Downloading and processing data...",
     "updateSuccess": "Suspected locations updated successfully",

lib/localizations/es.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Datos de permisos de servicios públicos que indican posibles sitios de instalación de infraestructura de vigilancia",
     "dataSourceCredit": "Recopilación y alojamiento de datos proporcionado por alprwatch.org",
     "minimumDistance": "Distancia Mínima de Nodos Reales",
-    "minimumDistanceSubtitle": "Ocultar ubicaciones sospechosas dentro de {}m de dispositivos de vigilancia existentes",
+    "minimumDistanceSubtitle": "Ocultar ubicaciones sospechosas dentro de {} de dispositivos de vigilancia existentes",
     "updating": "Actualizando Ubicaciones Sospechosas",
     "downloadingAndProcessing": "Descargando y procesando datos...",
     "updateSuccess": "Ubicaciones sospechosas actualizadas exitosamente",

lib/localizations/fr.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Données de permis de services publics indiquant des sites d'installation potentiels d'infrastructure de surveillance",
     "dataSourceCredit": "Collecte et hébergement des données fournis par alprwatch.org",
     "minimumDistance": "Distance Minimale des Nœuds Réels",
-    "minimumDistanceSubtitle": "Masquer les emplacements suspects dans un rayon de {}m des dispositifs de surveillance existants",
+    "minimumDistanceSubtitle": "Masquer les emplacements suspects dans un rayon de {} des dispositifs de surveillance existants",
     "updating": "Mise à Jour des Emplacements Suspects",
     "downloadingAndProcessing": "Téléchargement et traitement des données...",
     "updateSuccess": "Emplacements suspects mis à jour avec succès",

lib/localizations/it.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Dati dei permessi dei servizi pubblici che indicano potenziali siti di installazione di infrastrutture di sorveglianza",
     "dataSourceCredit": "Raccolta e hosting dei dati forniti da alprwatch.org",
     "minimumDistance": "Distanza Minima dai Nodi Reali",
-    "minimumDistanceSubtitle": "Nascondi posizioni sospette entro {}m dai dispositivi di sorveglianza esistenti",
+    "minimumDistanceSubtitle": "Nascondi posizioni sospette entro {} dai dispositivi di sorveglianza esistenti",
     "updating": "Aggiornamento Posizioni Sospette",
     "downloadingAndProcessing": "Scaricamento e elaborazione dati...",
     "updateSuccess": "Posizioni sospette aggiornate con successo",

lib/localizations/nl.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Nutsbedrijf vergunning data die mogelijke surveillance infrastructuur installatie sites aangeeft",
     "dataSourceCredit": "Gegevens verzameling en hosting geleverd door alprwatch.org",
     "minimumDistance": "Minimum Afstand van Echte Nodes",
-    "minimumDistanceSubtitle": "Verberg verdachte locaties binnen {}m van bestaande surveillance apparaten",
+    "minimumDistanceSubtitle": "Verberg verdachte locaties binnen {} van bestaande surveillance apparaten",
     "updating": "Verdachte Locaties Bijwerken",
     "downloadingAndProcessing": "Data downloaden en verwerken...",
     "updateSuccess": "Verdachte locaties succesvol bijgewerkt",

lib/localizations/pl.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Dane pozwoleń użyteczności publicznej wskazujące potencjalne miejsca instalacji infrastruktury nadzoru",
     "dataSourceCredit": "Zbieranie danych i hosting zapewnione przez alprwatch.org",
     "minimumDistance": "Minimalna Odległość od Rzeczywistych Węzłów",
-    "minimumDistanceSubtitle": "Ukryj podejrzane lokalizacje w promieniu {}m od istniejących urządzeń nadzoru",
+    "minimumDistanceSubtitle": "Ukryj podejrzane lokalizacje w promieniu {} od istniejących urządzeń nadzoru",
     "updating": "Aktualizowanie Podejrzanych Lokalizacji",
     "downloadingAndProcessing": "Pobieranie i przetwarzanie danych...",
     "updateSuccess": "Podejrzane lokalizacje zaktualizowane pomyślnie",

lib/localizations/pt.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Dados de licenças de serviços públicos indicando possíveis locais de instalação de infraestrutura de vigilância",
     "dataSourceCredit": "Coleta e hospedagem de dados fornecidas por alprwatch.org",
     "minimumDistance": "Distância Mínima de Nós Reais",
-    "minimumDistanceSubtitle": "Ocultar localizações suspeitas dentro de {}m de dispositivos de vigilância existentes",
+    "minimumDistanceSubtitle": "Ocultar localizações suspeitas dentro de {} de dispositivos de vigilância existentes",
     "updating": "Atualizando Localizações Suspeitas",
     "downloadingAndProcessing": "Baixando e processando dados...",
     "updateSuccess": "Localizações suspeitas atualizadas com sucesso",

lib/localizations/tr.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Potansiyel gözetleme altyapısı kurulum sitelerini gösteren altyapı izin verileri",
     "dataSourceCredit": "Veri toplama ve barındırma alprwatch.org tarafından sağlanır",
     "minimumDistance": "Gerçek Düğümlerden Minimum Mesafe",
-    "minimumDistanceSubtitle": "Mevcut gözetleme cihazlarının {}m yakınındaki şüpheli konumları gizle",
+    "minimumDistanceSubtitle": "Mevcut gözetleme cihazlarının {} yakınındaki şüpheli konumları gizle",
     "updating": "Şüpheli Konumlar Güncelleniyor",
     "downloadingAndProcessing": "Veri indiriliyor ve işleniyor...",
     "updateSuccess": "Şüpheli konumlar başarıyla güncellendi",

lib/localizations/uk.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "Дані дозволів комунальних служб, що вказують на потенційні сайти встановлення інфраструктури спостереження",
     "dataSourceCredit": "Збір даних та хостинг надається alprwatch.org",
     "minimumDistance": "Мінімальна Відстань від Реальних Вузлів",
-    "minimumDistanceSubtitle": "Приховати підозрілі локації в межах {}м від існуючих пристроїв спостереження",
+    "minimumDistanceSubtitle": "Приховати підозрілі локації в межах {} від існуючих пристроїв спостереження",
     "updating": "Оновлення Підозрілих Локацій",
     "downloadingAndProcessing": "Завантаження та обробка даних...",
     "updateSuccess": "Підозрілі локації успішно оновлено",

lib/localizations/zh.json

@@ -526,7 +526,7 @@
     "dataSourceDescription": "公用事业许可数据，表明潜在的监控基础设施安装站点",
     "dataSourceCredit": "数据收集和托管由 alprwatch.org 提供",
     "minimumDistance": "与真实节点的最小距离",
-    "minimumDistanceSubtitle": "隐藏现有监控设备{}米范围内的疑似位置",
+    "minimumDistanceSubtitle": "隐藏现有监控设备{}范围内的疑似位置",
     "updating": "正在更新疑似位置",
     "downloadingAndProcessing": "正在下载和处理数据...",
     "updateSuccess": "疑似位置更新成功",

lib/screens/about_screen.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:url_launcher/url_launcher.dart';
+import '../dev_config.dart';
 import '../services/localization_service.dart';
 import '../services/nuclear_reset_service.dart';
 import '../widgets/welcome_dialog.dart';
@@ -87,7 +88,7 @@ class AboutScreen extends StatelessWidget {
               _buildHelpLinks(context),
               
               // Dev-only nuclear reset button at very bottom
-              if (kDebugMode) ...[
+              if (kDebugMode || kEnableDevelopmentModes) ...[
                 const SizedBox(height: 32),
                 _buildDevNuclearResetButton(context),
                 const SizedBox(height: 16),

lib/screens/operator_profile_editor.dart

@@ -155,8 +155,13 @@ class _OperatorProfileEditorState extends State<OperatorProfileEditor> {
     
     final tagMap = <String, String>{};
     for (final e in _tags) {
-      if (e.key.trim().isEmpty) continue; // Skip only if key is empty
-      tagMap[e.key.trim()] = e.value.trim(); // Allow empty values for refinement
+      final key = e.key.trim();
+      final value = e.value.trim();
+      
+      // Skip if key is empty OR value is empty (no empty values for operator profiles)
+      if (key.isEmpty || value.isEmpty) continue;
+      
+      tagMap[key] = value;
     }
     
     final newProfile = widget.profile.copyWith(

lib/screens/settings/sections/operator_profiles_section.dart

@@ -54,47 +54,64 @@ class OperatorProfilesSection extends StatelessWidget {
                 ),
               )
             else
-              ...appState.operatorProfiles.map(
-                (p) => ListTile(
-                  title: Text(p.name),
-                  subtitle: Text(locService.t('operatorProfiles.tagsCount', params: [p.tags.length.toString()])),
-                  trailing: PopupMenuButton(
-                    itemBuilder: (context) => [
-                      PopupMenuItem(
-                        value: 'edit',
-                        child: Row(
-                          children: [
-                            const Icon(Icons.edit),
-                            const SizedBox(width: 8),
-                            Text(locService.t('actions.edit')),
-                          ],
-                        ),
+              ReorderableListView.builder(
+                shrinkWrap: true,
+                physics: const NeverScrollableScrollPhysics(),
+                itemCount: appState.operatorProfiles.length,
+                onReorder: (oldIndex, newIndex) {
+                  appState.reorderOperatorProfiles(oldIndex, newIndex);
+                },
+                itemBuilder: (context, index) {
+                  final p = appState.operatorProfiles[index];
+                  return ListTile(
+                    key: ValueKey(p.id),
+                    leading: ReorderableDragStartListener(
+                      index: index,
+                      child: const Icon(
+                        Icons.drag_handle,
+                        color: Colors.grey,
                       ),
-                      PopupMenuItem(
-                        value: 'delete',
-                        child: Row(
-                          children: [
-                            const Icon(Icons.delete, color: Colors.red),
-                            const SizedBox(width: 8),
-                            Text(locService.t('operatorProfiles.deleteOperatorProfile'), style: const TextStyle(color: Colors.red)),
-                          ],
-                        ),
-                      ),
-                    ],
-                    onSelected: (value) {
-                      if (value == 'edit') {
-                        Navigator.push(
-                          context,
-                          MaterialPageRoute(
-                            builder: (_) => OperatorProfileEditor(profile: p),
+                    ),
+                    title: Text(p.name),
+                    subtitle: Text(locService.t('operatorProfiles.tagsCount', params: [p.tags.length.toString()])),
+                    trailing: PopupMenuButton(
+                      itemBuilder: (context) => [
+                        PopupMenuItem(
+                          value: 'edit',
+                          child: Row(
+                            children: [
+                              const Icon(Icons.edit),
+                              const SizedBox(width: 8),
+                              Text(locService.t('actions.edit')),
+                            ],
                           ),
-                        );
-                      } else if (value == 'delete') {
-                        _showDeleteProfileDialog(context, p);
-                      }
-                    },
-                  ),
-                ),
+                        ),
+                        PopupMenuItem(
+                          value: 'delete',
+                          child: Row(
+                            children: [
+                              const Icon(Icons.delete, color: Colors.red),
+                              const SizedBox(width: 8),
+                              Text(locService.t('operatorProfiles.deleteOperatorProfile'), style: const TextStyle(color: Colors.red)),
+                            ],
+                          ),
+                        ),
+                      ],
+                      onSelected: (value) {
+                        if (value == 'edit') {
+                          Navigator.push(
+                            context,
+                            MaterialPageRoute(
+                              builder: (_) => OperatorProfileEditor(profile: p),
+                            ),
+                          );
+                        } else if (value == 'delete') {
+                          _showDeleteProfileDialog(context, p);
+                        }
+                      },
+                    ),
+                  );
+                },
               ),
           ],
         );

lib/services/deep_link_service.dart

@@ -3,8 +3,11 @@ import 'package:app_links/app_links.dart';
 import 'package:flutter/material.dart';
 
 import '../models/node_profile.dart';
+import '../models/operator_profile.dart';
 import 'profile_import_service.dart';
+import 'operator_profile_import_service.dart';
 import '../screens/profile_editor.dart';
+import '../screens/operator_profile_editor.dart';
 
 class DeepLinkService {
   static final DeepLinkService _instance = DeepLinkService._internal();
@@ -86,8 +89,16 @@ class DeepLinkService {
     }
   }
   
-  /// Handle profile add deep link: `deflockapp://profiles/add?p=<base64>`
+  /// Handle profile add deep link: `deflockapp://profiles/add?p=<base64>` or `deflockapp://profiles/add?op=<base64>`
   void _handleAddProfileLink(Uri uri) {
+    // Check for operator profile parameter first
+    final operatorBase64Data = uri.queryParameters['op'];
+    if (operatorBase64Data != null && operatorBase64Data.isNotEmpty) {
+      _handleOperatorProfileImport(operatorBase64Data);
+      return;
+    }
+    
+    // Otherwise check for device profile parameter
     final base64Data = uri.queryParameters['p'];
     
     if (base64Data == null || base64Data.isEmpty) {
@@ -107,6 +118,20 @@ class DeepLinkService {
     _navigateToProfileEditor(profile);
   }
   
+  /// Handle operator profile import from deep link
+  void _handleOperatorProfileImport(String base64Data) {
+    // Parse operator profile from base64
+    final operatorProfile = OperatorProfileImportService.parseProfileFromBase64(base64Data);
+    
+    if (operatorProfile == null) {
+      _showError('Invalid operator profile data');
+      return;
+    }
+    
+    // Navigate to operator profile editor with the imported profile
+    _navigateToOperatorProfileEditor(operatorProfile);
+  }
+  
   /// Navigate to profile editor with pre-filled profile data
   void _navigateToProfileEditor(NodeProfile profile) {
     final context = _navigatorKey?.currentContext;
@@ -124,6 +149,23 @@ class DeepLinkService {
     );
   }
   
+  /// Navigate to operator profile editor with pre-filled operator profile data
+  void _navigateToOperatorProfileEditor(OperatorProfile operatorProfile) {
+    final context = _navigatorKey?.currentContext;
+    
+    if (context == null) {
+      debugPrint('[DeepLinkService] No navigator context available');
+      return;
+    }
+    
+    Navigator.push(
+      context,
+      MaterialPageRoute(
+        builder: (_) => OperatorProfileEditor(profile: operatorProfile),
+      ),
+    );
+  }
+  
   /// Show error message to user
   void _showError(String message) {
     final context = _navigatorKey?.currentContext;

lib/services/operator_profile_import_service.dart

@@ -0,0 +1,100 @@
+import 'dart:convert';
+import 'package:flutter/foundation.dart';
+import 'package:uuid/uuid.dart';
+
+import '../models/operator_profile.dart';
+
+class OperatorProfileImportService {
+  // Maximum size for base64 encoded profile data (approx 50KB decoded)
+  static const int maxBase64Length = 70000;
+  
+  /// Parse and validate an operator profile from a base64-encoded JSON string
+  /// Returns null if parsing/validation fails
+  static OperatorProfile? parseProfileFromBase64(String base64Data) {
+    try {
+      // Basic size validation before expensive decode
+      if (base64Data.length > maxBase64Length) {
+        debugPrint('[OperatorProfileImportService] Base64 data too large: ${base64Data.length} characters');
+        return null;
+      }
+
+      // Decode base64
+      final jsonBytes = base64Decode(base64Data);
+      final jsonString = utf8.decode(jsonBytes);
+      
+      // Parse JSON
+      final jsonData = jsonDecode(jsonString) as Map<String, dynamic>;
+      
+      // Validate and sanitize the profile data
+      final sanitizedProfile = _validateAndSanitizeProfile(jsonData);
+      return sanitizedProfile;
+      
+    } catch (e) {
+      debugPrint('[OperatorProfileImportService] Failed to parse profile from base64: $e');
+      return null;
+    }
+  }
+  
+  /// Validate operator profile structure and sanitize all string values
+  static OperatorProfile? _validateAndSanitizeProfile(Map<String, dynamic> data) {
+    try {
+      // Extract and sanitize required fields
+      final name = _sanitizeString(data['name']);
+      if (name == null || name.isEmpty) {
+        debugPrint('[OperatorProfileImportService] Operator profile name is required');
+        return null;
+      }
+      
+      // Extract and sanitize tags
+      final tagsData = data['tags'];
+      if (tagsData is! Map<String, dynamic>) {
+        debugPrint('[OperatorProfileImportService] Operator profile tags must be a map');
+        return null;
+      }
+      
+      final sanitizedTags = <String, String>{};
+      for (final entry in tagsData.entries) {
+        final key = _sanitizeString(entry.key);
+        final value = _sanitizeString(entry.value);
+        
+        if (key != null && key.isNotEmpty) {
+          // Allow empty values for refinement purposes
+          sanitizedTags[key] = value ?? '';
+        }
+      }
+      
+      if (sanitizedTags.isEmpty) {
+        debugPrint('[OperatorProfileImportService] Operator profile must have at least one valid tag');
+        return null;
+      }
+      
+      return OperatorProfile(
+        id: const Uuid().v4(), // Always generate new ID for imported profiles
+        name: name,
+        tags: sanitizedTags,
+      );
+      
+    } catch (e) {
+      debugPrint('[OperatorProfileImportService] Failed to validate operator profile: $e');
+      return null;
+    }
+  }
+  
+  /// Sanitize a string value by trimming and removing potentially harmful characters
+  static String? _sanitizeString(dynamic value) {
+    if (value == null) return null;
+    
+    final str = value.toString().trim();
+    
+    // Remove control characters and limit length
+    final sanitized = str.replaceAll(RegExp(r'[\x00-\x1F\x7F]'), '');
+    
+    // Limit length to prevent abuse
+    const maxLength = 500;
+    if (sanitized.length > maxLength) {
+      return sanitized.substring(0, maxLength);
+    }
+    
+    return sanitized;
+  }
+}

lib/state/operator_profile_state.dart

@@ -1,12 +1,16 @@
 import 'package:flutter/material.dart';
+import 'package:shared_preferences/shared_preferences.dart';
 
 import '../models/operator_profile.dart';
 import '../services/operator_profile_service.dart';
 
 class OperatorProfileState extends ChangeNotifier {
+  static const String _profileOrderPrefsKey = 'operator_profile_order';
+  
   final List<OperatorProfile> _profiles = [];
+  List<String> _customOrder = []; // List of profile IDs in user's preferred order
 
-  List<OperatorProfile> get profiles => List.unmodifiable(_profiles);
+  List<OperatorProfile> get profiles => List.unmodifiable(_getOrderedProfiles());
 
   Future<void> init({bool addDefaults = false}) async {
     _profiles.addAll(await OperatorProfileService().load());
@@ -16,6 +20,10 @@ class OperatorProfileState extends ChangeNotifier {
       _profiles.addAll(OperatorProfile.getDefaults());
       await OperatorProfileService().save(_profiles);
     }
+    
+    // Load custom order from prefs
+    final prefs = await SharedPreferences.getInstance();
+    _customOrder = prefs.getStringList(_profileOrderPrefsKey) ?? [];
   }
 
   void addOrUpdateProfile(OperatorProfile p) {
@@ -34,4 +42,56 @@ class OperatorProfileState extends ChangeNotifier {
     OperatorProfileService().save(_profiles);
     notifyListeners();
   }
+
+  // Reorder profiles (for drag-and-drop in settings)
+  void reorderProfiles(int oldIndex, int newIndex) {
+    final orderedProfiles = _getOrderedProfiles();
+    
+    // Standard Flutter reordering logic
+    if (oldIndex < newIndex) {
+      newIndex -= 1;
+    }
+    final item = orderedProfiles.removeAt(oldIndex);
+    orderedProfiles.insert(newIndex, item);
+    
+    // Update custom order with new sequence
+    _customOrder = orderedProfiles.map((p) => p.id).toList();
+    _saveCustomOrder();
+    notifyListeners();
+  }
+  
+  // Get profiles in custom order, with unordered profiles at the end
+  List<OperatorProfile> _getOrderedProfiles() {
+    if (_customOrder.isEmpty) {
+      return List.from(_profiles);
+    }
+    
+    final ordered = <OperatorProfile>[];
+    final profilesById = {for (final p in _profiles) p.id: p};
+    
+    // Add profiles in custom order
+    for (final id in _customOrder) {
+      final profile = profilesById[id];
+      if (profile != null) {
+        ordered.add(profile);
+        profilesById.remove(id);
+      }
+    }
+    
+    // Add any remaining profiles that weren't in the custom order
+    ordered.addAll(profilesById.values);
+    
+    return ordered;
+  }
+  
+  // Save custom order to disk
+  Future<void> _saveCustomOrder() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setStringList(_profileOrderPrefsKey, _customOrder);
+    } catch (e) {
+      // Fail gracefully in tests or if SharedPreferences isn't available
+      debugPrint('[OperatorProfileState] Failed to save custom order: $e');
+    }
+  }
 }

pubspec.yaml

@@ -1,7 +1,7 @@
 name: deflockapp
 description: Map public surveillance infrastructure with OpenStreetMap
 publish_to: "none"
-version: 2.10.0+54   # The thing after the + is the version code, incremented with each release
+version: 2.10.1+55   # The thing after the + is the version code, incremented with each release
 
 environment:
   sdk: ">=3.10.3 <4.0.0"   # Resolved dependency floor (Dart 3.10.3 = Flutter 3.38+)