New Features

    Regional admins can now enforce hybrid mode per-zone via the API; when enabled, hybrid mode is automatically activated and the toggle is locked on the Settings screen with a "Forced Enabled by Regional Admin" label
    Regional admins can set a minimum auto-ping interval per-zone; interval options below the minimum are greyed out in Settings with a "Disabled by Regional Admin" label
    If a user's saved interval falls below the admin-configured minimum, it is automatically bumped up on connect

Author: MrAlders0n

lib/providers/app_state_provider.dart

@@ -390,6 +390,8 @@ class AppStateProvider extends ChangeNotifier with WidgetsBindingObserver {
   bool get rxAllowed => _apiService.rxAllowed;
   bool get hasApiSession => _apiService.hasSession;
   bool get isApiRxOnlyMode => hasApiSession && !txAllowed && rxAllowed;
+  bool get enforceHybrid => _apiService.enforceHybrid;
+  int get minModeInterval => _apiService.minModeInterval;
 
   // Offline mode
   bool get offlineMode => _preferences.offlineMode;
@@ -1099,6 +1101,18 @@ class AppStateProvider extends ChangeNotifier with WidgetsBindingObserver {
         debugLog('[CONN] No regional scope — using unscoped flood');
       }
 
+      // Enforce hybrid mode if required by regional admin
+      if (_apiService.enforceHybrid && !_preferences.hybridModeEnabled) {
+        _preferences = _preferences.copyWith(hybridModeEnabled: true);
+        debugLog('[CONN] Hybrid mode force-enabled by regional admin');
+      }
+
+      // Enforce minimum auto-ping interval if required by regional admin
+      if (_preferences.autoPingInterval < _apiService.minModeInterval) {
+        _preferences = _preferences.copyWith(autoPingInterval: _apiService.minModeInterval);
+        debugLog('[CONN] Auto-ping interval bumped to ${_apiService.minModeInterval}s by regional admin');
+      }
+
       // Create ping service with wakelock (create new instance per connection)
       _pingService = PingService(
         gpsService: _gpsService,

lib/screens/settings_screen.dart

@@ -242,9 +242,14 @@ class _SettingsScreenState extends State<SettingsScreen> {
                 ),
               ],
             ),
-            subtitle: const Text('Combines Active and Passive modes'),
-            value: prefs.hybridModeEnabled,
-            onChanged: isAutoMode ? null : (value) {
+            subtitle: appState.enforceHybrid
+                ? const Text(
+                    'Forced Enabled by Regional Admin',
+                    style: TextStyle(color: Colors.amber),
+                  )
+                : const Text('Combines Active and Passive modes'),
+            value: appState.enforceHybrid ? true : prefs.hybridModeEnabled,
+            onChanged: (isAutoMode || appState.enforceHybrid) ? null : (value) {
               appState.updatePreferences(prefs.copyWith(hybridModeEnabled: value));
             },
           ),
@@ -1083,7 +1088,16 @@ class _SettingsScreenState extends State<SettingsScreen> {
   }
 
   void _showIntervalSelector(BuildContext context, AppStateProvider appState) {
-    final currentInterval = appState.preferences.autoPingInterval;
+    final minInterval = appState.minModeInterval;
+    var currentInterval = appState.preferences.autoPingInterval;
+
+    // Auto-bump if current interval is below the admin minimum
+    if (currentInterval < minInterval) {
+      currentInterval = minInterval;
+      appState.updatePreferences(
+        appState.preferences.copyWith(autoPingInterval: minInterval),
+      );
+    }
 
     showDialog(
       context: context,
@@ -1102,18 +1116,37 @@ class _SettingsScreenState extends State<SettingsScreen> {
           child: Column(
             mainAxisSize: MainAxisSize.min,
             children: AutoPingInterval.values.map((interval) {
-              final isSelected = interval == currentInterval;
+              final isDisabled = interval < minInterval;
+
+              String description;
+              if (interval == 15) {
+                description = 'Fast (More coverage, causes more mesh load)';
+              } else if (interval == 30) {
+                description = 'Normal (Balanced coverage and mesh load)';
+              } else {
+                description = 'Slow (Less coverage, little mesh load)';
+              }
 
-              return RadioListTile<int>(
+              final tile = RadioListTile<int>(
                 title: Text('$interval seconds'),
-                subtitle: Text(interval == 15
-                    ? 'Fast (More coverage, causes more mesh load)'
-                    : interval == 30
-                        ? 'Normal (Balanced coverage and mesh load)'
-                        : 'Slow (Less coverage, little mesh load)'),
+                subtitle: isDisabled
+                    ? const Text(
+                        'Disabled by Regional Admin',
+                        style: TextStyle(color: Colors.amber),
+                      )
+                    : Text(description),
                 value: interval,
-                selected: isSelected,
               );
+
+              if (isDisabled) {
+                return IgnorePointer(
+                  child: Opacity(
+                    opacity: 0.5,
+                    child: tile,
+                  ),
+                );
+              }
+              return tile;
             }).toList(),
           ),
         ),

lib/services/api_service.dart

@@ -41,6 +41,8 @@ class ApiService {
   Function? _onSessionExpiring;
   List<String> _channels = [];
   List<String> _scopes = [];
+  bool _enforceHybrid = false;
+  int _minModeInterval = 15;
 
   /// Callback to get current GPS coordinates for heartbeat
   /// Returns (lat, lon) or null if GPS is not available
@@ -52,6 +54,12 @@ class ApiService {
   /// Regional scopes from auth response (e.g., ['ottawa'])
   List<String> get scopes => List.unmodifiable(_scopes);
 
+  /// Whether hybrid mode is enforced by regional admin
+  bool get enforceHybrid => _enforceHybrid;
+
+  /// Minimum auto-ping interval enforced by regional admin (seconds)
+  int get minModeInterval => _minModeInterval;
+
   ApiService({http.Client? client}) : _client = client ?? http.Client();
 
   /// Sanitize payload by removing sensitive fields for logging
@@ -315,6 +323,21 @@ class ApiService {
           _scopes = [];
         }
 
+        // Parse enforce_hybrid flag from auth response
+        _enforceHybrid = data['enforce_hybrid'] == true;
+        if (_enforceHybrid) {
+          debugLog('[API] Regional admin enforces hybrid mode');
+        }
+
+        // Parse min_mode_interval from auth response
+        final minInterval = data['min_mode_interval'];
+        if (minInterval is int && minInterval > 0) {
+          _minModeInterval = minInterval;
+          debugLog('[API] Regional admin min interval: ${_minModeInterval}s');
+        } else {
+          _minModeInterval = 15;
+        }
+
         // Note: Heartbeat is enabled by AppStateProvider when auto mode starts
         // (not on initial auth, since heartbeat is only for auto mode)
       } else if (reason == 'disconnect') {
@@ -614,6 +637,8 @@ class ApiService {
     _sessionExpiresAt = null;
     _channels = [];
     _scopes = [];
+    _enforceHybrid = false;
+    _minModeInterval = 15;
     _heartbeatTimer?.cancel();
     _heartbeatTimer = null;
     debugLog('[API] Session cleared');