ser

lib/logic/ad_manager.dart

@@ -29,7 +29,8 @@ class AdManager extends ChangeNotifier {
     _preloadAd();
   }
 
-  /// Internal helper to load an ad and return a Future when it's ready
+  /// Loads a rewarded ad in the background and returns a Future when ready.
+  /// Safe to call multiple times — re-entrant calls wait on the same load.
   Future<bool> _preloadAd() async {
     // If already loaded, return instantly
     if (_isAdLoaded) return true;

lib/logic/hivemind_service.dart

@@ -1,5 +1,6 @@
 import 'dart:async';
 import 'dart:convert';
+import 'package:flutter/foundation.dart';
 import 'package:http/http.dart' as http;
 import 'package:paladinvpn/logic/app_config.dart';
 import 'package:paladinvpn/logic/crypto_service.dart';
@@ -14,20 +15,8 @@ class HivemindService {
     
     final url = Uri.parse('${AppConfig.hivemindApiBase}/session/status?device_id=$deviceId');
 
-    // ── TEMPORARY AD BYPASS HACK FOR TESTING ──
-    // Since you disabled the crypto signature check on the Python server,
-    // we can just send a fake "Ad Watched" ping from the app directly.
-    try {
-      final customData = jsonEncode({
-        'device_id': deviceId,
-        'public_key': keys['publicKey']!,
-        'ad_type': 'main_ad',
-      });
-      final fakeAdmobPingUrl = Uri.parse(
-          '${AppConfig.hivemindApiBase}/admob/callback?signature=test&key_id=test&custom_data=${Uri.encodeComponent(customData)}');
-      await http.get(fakeAdmobPingUrl).timeout(const Duration(seconds: 8));
-    } catch (_) {}
-    // ──────────────────────────────────────────
+    // AdMob SSV is handled server-to-server by Google.
+    // The app waits for the server to activate the session via the real callback.
 
     int attempts = 0;
     while (attempts < 15) {
@@ -36,8 +25,7 @@ class HivemindService {
         if (response.statusCode == 200) {
           final data = jsonDecode(response.body);
           
-          // Debugging log to see exactly what the server returned
-          print('[HivemindService] Polling response: ${response.body}');
+          debugPrint('[HivemindService] Session active, constructing config…');
           
           if (data['active'] == true && data['client_ip'] != null && data['server_pubkey'] != null) {
             final clientIp = data['client_ip'];
@@ -70,10 +58,10 @@ PersistentKeepalive = ${AppConfig.persistentKeepalive}
             return configText;
           }
         } else {
-          print('[HivemindService] Non-200 status: ${response.statusCode}');
+          debugPrint('[HivemindService] Non-200 status: ${response.statusCode}');
         }
       } catch (e) {
-        print('[HivemindService] Polling exception: $e');
+        debugPrint('[HivemindService] Polling exception: $e');
         // Ignore network errors and keep polling
       }
       

lib/logic/session_timer.dart

@@ -7,48 +7,58 @@ import 'package:paladinvpn/logic/vpn_connection.dart';
 import 'package:paladinvpn/logic/crypto_service.dart';
 import 'package:paladinvpn/components/notification.dart';
 
-/// SessionTimer acts as the client-side session authority for the VPN tunnel.
-/// 
-/// It connects to the Hivemind API on the server to sync the true remaining
-/// time, data quotas, speed, and throttling status.
+/// SessionTimer is the client-side session authority for the VPN tunnel.
+///
+/// Polls the Hivemind API to sync remaining time, data quotas, speed, and
+/// throttling status.  Rather than guessing the session length optimistically,
+/// it waits for the first successful sync before the local countdown begins.
 class SessionTimer extends ChangeNotifier {
   Timer? _timer;
   int _tickCount = 0;
-  
+
   final VpnConnection vpnConnection;
 
-  // ── Session State ──
+  // ── Session State ──────────────────────────────────────────────────────────
   int _remainingSeconds = 0;
-  int _quotaBytes = 0;
-  int _usedBytes = 0;
-  bool _isThrottled = false;
-  
-  // ── Speed State ──
-  int _lastUsedBytes = 0;
-  double _currentSpeedKbps = 0.0; // Total speed (RX+TX)
+  int _quotaBytes      = 0;
+  int _usedBytes       = 0;
+  bool _isThrottled    = false;
+
+  // ── Sync / Network Health ──────────────────────────────────────────────────
+  bool _hasSyncedOnce       = false;
+  int  _consecutiveFailures = 0;
+  bool _isDisconnecting     = false;
+
+  /// Maximum consecutive sync failures before the local countdown is paused
+  /// to avoid showing a false "expired" state while the network is down.
+  static const int _maxConsecutiveFailures = 3;
+
+  /// Seconds between server polls (reduced from 3 to ease server load).
+  static const int _pollIntervalSeconds = 5;
+
+  // ── Speed State ────────────────────────────────────────────────────────────
+  int    _lastUsedBytes    = 0;
+  double _currentSpeedKbps = 0.0;
+
+  // ── Notification dedup ─────────────────────────────────────────────────────
+  String _lastNotifTime  = '';
+  String _lastNotifSpeed = '';
 
   SessionTimer({required this.vpnConnection}) {
     vpnConnection.addListener(_onVpnConnectionChanged);
   }
 
-  /// Fires whenever VpnConnection state changes.
-  /// Only acts during startup restoration — normal connects go through ConnectButton.
-  void _onVpnConnectionChanged() {
-    if (vpnConnection.status == VpnStatus.connected &&
-        !isRunning &&
-        vpnConnection.isStartupRestoration) {
-      start('resume');
-    }
-  }
+  // ── Public Getters ─────────────────────────────────────────────────────────
 
-  int get remaining => _remainingSeconds;
-  bool get isRunning => _timer != null && _timer!.isActive;
-  bool get isExpired => _remainingSeconds <= 0 && !isRunning;
-  
-  int get quotaBytes => _quotaBytes;
-  int get usedBytes => _usedBytes;
-  int get remainingBytes => _quotaBytes > _usedBytes ? _quotaBytes - _usedBytes : 0;
-  bool get isThrottled => _isThrottled;
+  int  get remaining        => _remainingSeconds;
+  bool get isRunning        => _timer != null && _timer!.isActive;
+  bool get isExpired        => _remainingSeconds <= 0 && !isRunning;
+  bool get hasSyncedOnce    => _hasSyncedOnce;
+
+  int    get quotaBytes     => _quotaBytes;
+  int    get usedBytes      => _usedBytes;
+  int    get remainingBytes => _quotaBytes > _usedBytes ? _quotaBytes - _usedBytes : 0;
+  bool   get isThrottled    => _isThrottled;
   double get currentSpeedKbps => _currentSpeedKbps;
 
   String get formatted {
@@ -75,51 +85,80 @@ class SessionTimer extends ChangeNotifier {
   }
 
   double get progress {
-    // Max duration is generally 60 or 90 minutes. We'll base the ring purely on data usage or just standard time
-    // For UI simplicity, we'll return data progress:
     if (_quotaBytes == 0) return 0.0;
     return (_quotaBytes - _usedBytes) / _quotaBytes;
   }
 
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
+
+  /// Fires whenever VpnConnection state changes.
+  /// Only auto-restarts the timer during startup restoration —
+  /// normal connects are driven by [ConnectButton].
+  void _onVpnConnectionChanged() {
+    if (vpnConnection.status == VpnStatus.connected &&
+        !isRunning &&
+        vpnConnection.isStartupRestoration) {
+      start('resume');
+    }
+  }
+
+  /// Starts the local countdown and begins server polling.
+  ///
+  /// Values are initialised at 0 — the UI shows "Syncing…" until the first
+  /// successful [_syncWithHivemind] returns real data.
   Future<void> start(String adType) async {
-    _remainingSeconds = 3600; // optimistic start
-    _quotaBytes = 2 * 1024 * 1024 * 1024;
-    _usedBytes = 0;
-    _lastUsedBytes = 0;
-    _currentSpeedKbps = 0.0;
-    _isThrottled = false;
-    _tickCount = 0;
-    
+    _remainingSeconds    = 0;
+    _quotaBytes          = 0;
+    _usedBytes           = 0;
+    _lastUsedBytes       = 0;
+    _currentSpeedKbps    = 0.0;
+    _isThrottled         = false;
+    _tickCount           = 0;
+    _hasSyncedOnce       = false;
+    _consecutiveFailures = 0;
+    _isDisconnecting     = false;
+
     _timer?.cancel();
     _timer = Timer.periodic(const Duration(seconds: 1), _tick);
-    
-    // Kick off an immediate sync so the UI shows real data right away
+
+    notifyListeners();
+
+    // Kick off the first sync — the UI will show real data as soon as it lands.
     _syncWithHivemind();
   }
 
   void _tick(Timer t) {
-    if (_remainingSeconds > 0) {
-      _remainingSeconds--;
+    // Only decrement the local clock after the first successful sync
+    // and while we are not in a network-blackout window.
+    if (_hasSyncedOnce && _consecutiveFailures < _maxConsecutiveFailures) {
+      if (_remainingSeconds > 0) {
+        _remainingSeconds--;
+      }
     }
 
     _tickCount++;
-    // Poll the server every 3 seconds to get live stats
-    if (_tickCount % 3 == 0) {
+    if (_tickCount % _pollIntervalSeconds == 0) {
       _syncWithHivemind();
     }
 
     notifyListeners();
   }
 
+  // ── Server Sync ────────────────────────────────────────────────────────────
+
   Future<void> _syncWithHivemind() async {
+    // Never sync while the user is explicitly disconnecting.
+    if (_isDisconnecting) return;
+
     try {
       final deviceId = await CryptoService.getDeviceId();
-      final url = Uri.parse('${AppConfig.hivemindApiBase}/session/status?device_id=$deviceId');
-      final response = await http.get(url).timeout(const Duration(seconds: 3));
-      
+      final url = Uri.parse(
+          '${AppConfig.hivemindApiBase}/session/status?device_id=$deviceId');
+      final response = await http.get(url).timeout(const Duration(seconds: 5));
+
       if (response.statusCode == 200) {
         final data = jsonDecode(response.body);
-        
+
         final bool active = data['active'] ?? false;
         if (!active) {
           // Server killed the session!
@@ -129,63 +168,88 @@ class SessionTimer extends ChangeNotifier {
         }
 
         _remainingSeconds = data['expires_in_seconds'] ?? _remainingSeconds;
-        _quotaBytes = data['quota_bytes'] ?? _quotaBytes;
-        _usedBytes = data['used_bytes'] ?? _usedBytes;
-        _isThrottled = data['is_throttled'] ?? false;
+        _quotaBytes       = data['quota_bytes']       ?? _quotaBytes;
+        _usedBytes        = data['used_bytes']        ?? _usedBytes;
+        _isThrottled      = data['is_throttled']      ?? false;
 
-        // Calculate speed over the polling interval
+        // ── Speed calculation over the polling interval ────────────────────
         final int deltaBytes = _usedBytes - _lastUsedBytes;
-        if (_lastUsedBytes > 0 && deltaBytes > 0) {
-          _currentSpeedKbps = (deltaBytes / 3) / 1024;
-        } else {
+        if (_hasSyncedOnce && deltaBytes > 0) {
+          _currentSpeedKbps = (deltaBytes / _pollIntervalSeconds) / 1024;
+        } else if (!_hasSyncedOnce) {
           _currentSpeedKbps = 0.0;
         }
         _lastUsedBytes = _usedBytes;
 
-        VpnNotificationManager.showOrUpdateStatus(
-          timeLeft: formatted,
-          speedKbps: '${_currentSpeedKbps.toStringAsFixed(2)} KB/s',
-        );
+        // ── Network is healthy — reset failure counter ─────────────────────
+        _consecutiveFailures = 0;
+        _hasSyncedOnce = true;
+
+        // ── Update notification (only when values actually change) ─────────
+        final speedText = _currentSpeedKbps > 0.5
+            ? '${_currentSpeedKbps.toStringAsFixed(1)} KB/s'
+            : 'Idle';
+        if (formatted != _lastNotifTime || speedText != _lastNotifSpeed) {
+          _lastNotifTime  = formatted;
+          _lastNotifSpeed = speedText;
+          VpnNotificationManager.showOrUpdateStatus(
+            timeLeft: formatted,
+            speedKbps: speedText,
+          );
+        }
 
         notifyListeners();
       } else if (response.statusCode == 404) {
-        // Peer not found on server (expired/deleted natively)
+        // Peer not found on server (expired / deleted natively)
         stop();
         vpnConnection.disconnect();
+      } else {
+        _markSyncFailure();
       }
     } catch (e) {
       debugPrint('Hivemind sync error: $e');
-      // If we can't reach the server, just let the local timer run
+      _markSyncFailure();
     }
   }
 
-  Future<void> addBonusTime() async {
-    final ip = vpnConnection.internalIp;
-    if (ip != null) {
-      try {
-        final deviceId = await CryptoService.getDeviceId();
-        await http.post(
-          Uri.parse('${AppConfig.hivemindApiBase}/session/start'),
-          headers: {'Content-Type': 'application/json'},
-          body: jsonEncode({
-            'ip': ip,
-            'device_id': deviceId,
-            'ad_type': 'bonus_ad'
-          }),
-        ).timeout(const Duration(seconds: 5));
-        
-        // Immediately sync to fetch the updated limits and un-throttled status
-        _syncWithHivemind();
-      } catch (e) {
-        debugPrint('Failed to add bonus time with Hivemind: $e');
-      }
+  /// Increments the failure counter; pauses the local countdown after
+  /// [_maxConsecutiveFailures] to avoid displaying a false "expired" clock.
+  void _markSyncFailure() {
+    _consecutiveFailures++;
+    if (_consecutiveFailures >= _maxConsecutiveFailures) {
+      notifyListeners(); // let the UI show "Reconnecting…"
     }
   }
 
+  // ── Bonus Time ─────────────────────────────────────────────────────────────
+
+  /// Called after the user watches a bonus rewarded ad.
+  ///
+  /// The actual session extension is handled server-side via the AdMob SSV
+  /// callback.  This method simply re-syncs so the UI picks up the new
+  /// limits and un-throttled status.
+  ///
+  /// Returns `true` if the sync succeeded, so the UI can decide whether to
+  /// show a success snackbar.
+  Future<bool> addBonusTime() async {
+    try {
+      await _syncWithHivemind();
+      return _hasSyncedOnce;
+    } catch (e) {
+      debugPrint('Bonus-time sync error: $e');
+      return false;
+    }
+  }
+
+  // ── Stop ───────────────────────────────────────────────────────────────────
+
   void stop() {
+    _isDisconnecting = true;
     _timer?.cancel();
     _timer = null;
-    _remainingSeconds = 0;
+    // Keep _remainingSeconds visible so the UI doesn't flash 00:00:00
+    // while the tunnel is tearing down.  The VpnConnection will drive the
+    // UI transition, and dispose() will do final cleanup.
     _currentSpeedKbps = 0.0;
     VpnNotificationManager.cancel();
     notifyListeners();

lib/logic/vpn_connection.dart

@@ -138,7 +138,17 @@ class VpnConnection extends ChangeNotifier {
   // The connect button uses this to decide whether to start the timer.
   Future<bool> connect() async {
     // Don't do anything if we're already connected or currently connecting
-    if (_status == VpnStatus.connected || _status == VpnStatus.connecting) return false;
+    if (_status == VpnStatus.connected || _status == VpnStatus.connecting) {
+      return false;
+    }
+
+    // Guard: native plugin never loaded (wrong arch, missing .so)
+    if (!kIsWeb && !_pluginAvailable) {
+      _errorMessage = 'VPN service unavailable. The native tunnel library '
+          'could not be loaded on this device.';
+      _setStatus(VpnStatus.error, 'Service unavailable');
+      return false;
+    }
 
     _setStatus(VpnStatus.connecting, 'Fetching config…');
     _errorMessage = null;
@@ -150,32 +160,39 @@ class VpnConnection extends ChangeNotifier {
       return true;
     }
 
-
-
-    // ── Step 2: Fetch config from Hivemind ──
+    // ── Step 1: Fetch WireGuard config from Hivemind ────────────────────
     String configText;
     try {
       configText = await HivemindService.fetchConfigWithPolling();
-      
-      // Parse the internal IP (e.g. "Address = 10.8.0.2/24" or "/32")
+
+      // Parse the internal IP (e.g. "Address = 10.8.0.2/16" or "/32")
       final regex = RegExp(r'Address\s*=\s*([0-9\.]+)/');
       final match = regex.firstMatch(configText);
       if (match != null) {
         internalIp = match.group(1);
       }
     } catch (e) {
-      debugPrint('Hivemind API error: $e');
-      // Set the exact error as the status message so the user can see it on screen
-      String errorMsg = e.toString().replaceAll('Exception: ', '');
-      if (errorMsg.length > 30) {
-        errorMsg = '${errorMsg.substring(0, 30)}...'; // keep it somewhat short for the UI
+      debugPrint('Hivemind config error: $e');
+      final raw = e.toString().replaceAll('Exception: ', '');
+      // Map the known failures to something the user can act on
+      if (raw.contains('timed out') || raw.contains('Session not activated')) {
+        _errorMessage = 'The server did not respond in time.\n'
+            'Check your internet connection and try again.';
+        _setStatus(VpnStatus.error, 'Server unreachable');
+      } else if (raw.contains('SocketException') ||
+                 raw.contains('Failed host lookup')) {
+        _errorMessage = 'Cannot reach the VPN server.\n'
+            'Make sure you have an active internet connection.';
+        _setStatus(VpnStatus.error, 'No internet');
+      } else {
+        _errorMessage = raw;
+        final short = raw.length > 35 ? '${raw.substring(0, 35)}…' : raw;
+        _setStatus(VpnStatus.error, short);
       }
-      _errorMessage = e.toString();
-      _setStatus(VpnStatus.error, errorMsg);
       return false;
     }
 
-    // ── Step 3: Start the WireGuard tunnel with the fetched config ─────────
+    // ── Step 2: Start the WireGuard tunnel with the fetched config ──────
     try {
       // Re-initialize to ensure VPN permission is granted before starting
       await _wireguard.initialize(interfaceName: 'Paladin0');
@@ -188,8 +205,39 @@ class VpnConnection extends ChangeNotifier {
       return true;
     } catch (e) {
       debugPrint('WireGuard tunnel error: $e');
-      _errorMessage = 'Tunnel failed to start.\nTry reconnecting.';
-      _setStatus(VpnStatus.error, 'Tunnel error');
+      final raw = e.toString();
+      if (raw.contains('VPN_PERMISSION_REQUESTED')) {
+        // Native plugin showed the VPN permission dialog — wait and retry
+        _setStatus(VpnStatus.connecting, 'Waiting for permission…');
+        await Future.delayed(const Duration(seconds: 2));
+        // Retry the tunnel start once the user has had time to grant permission
+        try {
+          await _wireguard.startVpn(
+            serverAddress: AppConfig.serverEndpoint,
+            wgQuickConfig: configText,
+            providerBundleIdentifier: 'com.paladinvpn.app.WireGuardProvider',
+          );
+          _setStatus(VpnStatus.connected, 'Secured');
+          return true;
+        } catch (retryError) {
+          debugPrint('WireGuard retry error: $retryError');
+          _errorMessage = 'VPN permission was denied.\n'
+              'Please grant the VPN permission and try again.';
+          _setStatus(VpnStatus.error, 'Permission denied');
+          return false;
+        }
+      } else if (raw.contains('Permission') || raw.contains('permissions')) {
+        _errorMessage = 'VPN permission was denied.\n'
+            'Please grant the VPN permission and try again.';
+        _setStatus(VpnStatus.error, 'Permission denied');
+      } else if (raw.contains('NameInvalid') || raw.contains('invalid')) {
+        _errorMessage = 'The WireGuard configuration is invalid.\n'
+            'Please contact support.';
+        _setStatus(VpnStatus.error, 'Bad config');
+      } else {
+        _errorMessage = 'Tunnel failed to start.\nTry reconnecting.';
+        _setStatus(VpnStatus.error, 'Tunnel error');
+      }
       return false;
     }
   }