feat: Enhance ad visibility control and improve countdown timer logic

Author: goku-kamehameha

lib/modules/main/presentation/screens/main_screen.dart

@@ -292,7 +292,11 @@ class _MainScreenState extends ConsumerState<MainScreen> {
         );
 
       default:
-        // Show ads only when connected to VPN and ad is loaded
+        // MainScreen controls ad visibility (Strategy Pattern approach)
+        // Works for both GoogleAdStrategy and InternalAdStrategy
+        // - nativeAdIsLoaded: true when ad is ready (Google or Internal)
+        // - showCountdown: true during 60-second display window
+        // - connected: only show when VPN is active
         final shouldShowAd = status == ConnectionStatus.connected && 
                              adsState.showCountdown && 
                              adsState.nativeAdIsLoaded;

lib/modules/main/presentation/widgets/ads/ads_state.dart

@@ -162,13 +162,9 @@ class AdsNotifier extends StateNotifier<AdsState> {
   }
 
   /// Start the countdown timer after ad is loaded and VPN connects
+  /// Always restarts to 60 seconds on each connection
   void startCountdownTimer() async {
-    if (_countdownTimer != null && _countdownTimer!.isActive) {
-      debugPrint('⏱️ Countdown already running, ignoring duplicate start');
-      return;
-    }
-
-    debugPrint('▶️ Starting new countdown timer');
+    debugPrint('▶️ Starting new countdown timer (60 seconds)');
     _countdownTimer?.cancel();
 
     // Clear any old persisted countdown before starting new one
@@ -189,10 +185,14 @@ class AdsNotifier extends StateNotifier<AdsState> {
   void _startCountdownFromValue(int startValue) {
     _countdownTimer?.cancel();
 
+    debugPrint('⏱️ Timer starting from $startValue seconds');
     _countdownTimer = Timer.periodic(const Duration(seconds: 1), (timer) {
       if (state.countdown > 0) {
-        state = state.copyWith(countdown: state.countdown - 1);
+        final newCount = state.countdown - 1;
+        debugPrint('⏱️ Countdown: $newCount');
+        state = state.copyWith(countdown: newCount);
       } else {
+        debugPrint('⏱️ Countdown finished - hiding ad');
         state = state.copyWith(
           showCountdown: false,
           // Keep ad loaded - just hide it until next connection

lib/modules/main/presentation/widgets/ads/strategy/google_ad_strategy.dart

@@ -68,10 +68,13 @@ class GoogleAdStrategy implements AdLoadingStrategy {
       // Check if we need to load a new ad
       if (_nativeAd != null) {
         final adsState = ref.read(adsProvider);
+        debugPrint('🔍 Cached ad found. State: nativeAdIsLoaded=${adsState.nativeAdIsLoaded}');
         if (adsState.nativeAdIsLoaded) {
           debugPrint('✅ Using existing valid ad');
           _hasInitialized = true;
           return;
+        } else {
+          debugPrint('⚠️ Cached ad exists but state says not loaded - will reload');
         }
       }
 
@@ -98,15 +101,19 @@ class GoogleAdStrategy implements AdLoadingStrategy {
       );
     }
 
-    // Reset ad loaded state BEFORE disposing to prevent showing disposed ad
-    if (_nativeAd != null) {
-      ref.read(adsProvider.notifier).setAdLoaded(false);
+    // Check if we already have a valid cached ad
+    final adsState = ref.read(adsProvider);
+    if (_nativeAd != null && adsState.nativeAdIsLoaded && !adsState.needsRefresh) {
+      debugPrint('✅ Reusing cached ad (still fresh)');
+      return AdLoadResult.success();
     }
 
     _isLoading = true;
 
-    // Dispose previous ad if exists
+    // Only dispose if we're reloading (ad is stale or failed)
     if (_nativeAd != null) {
+      debugPrint('🔄 Disposing stale/failed ad before reload');
+      ref.read(adsProvider.notifier).setAdLoaded(false);
       try {
         _nativeAd!.dispose();
         debugPrint('🗑️ Disposed previous ad');
@@ -233,7 +240,10 @@ class GoogleAdStrategy implements AdLoadingStrategy {
             analytics.logEvent(name: 'ad_impression', parameters: {});
           },
         ),
-        request: const AdRequest(),
+        request: const AdRequest(
+          keywords: ['privacy', 'security', 'technology', 'mobile', 'internet safety', 'data protection'],
+          contentUrl: 'defyxvpn://home',
+        ),
         nativeTemplateStyle: templateStyle,
       );
 
@@ -296,16 +306,17 @@ class GoogleAdStrategy implements AdLoadingStrategy {
 
       final adsState = ref.read(adsProvider);
 
-      // Load ad if we don't have one or previous load failed
-      if (_nativeAd == null || !adsState.nativeAdIsLoaded) {
+      // Check if we need to reload (no ad, failed load, or stale)
+      if (_nativeAd == null || !adsState.nativeAdIsLoaded || adsState.needsRefresh) {
         if (_isLoading) {
           debugPrint('⏳ Ad load already in progress...');
           return;
         }
 
         debugPrint('📱 Loading ad with real IP');
-        _hasInitialized = false;
-        initialize(ref);
+        loadAd(ref: ref);
+      } else {
+        debugPrint('✅ Keeping existing cached ad');
       }
       return;
     }

lib/modules/main/presentation/widgets/ads_widget.dart

@@ -16,6 +16,12 @@
 /// - Widget (this file): UI rendering, strategy selection, lifecycle management
 /// - Strategies: Ad loading logic, connection state handling, resource cleanup
 /// - State (ads_state.dart): Centralized state shared across all strategies
+/// - MainScreen: Controls when to show/hide ads (single source of truth)
+/// 
+/// **Visibility Control:**
+/// - MainScreen decides when to render AdsWidget (based on connection + countdown)
+/// - AdsWidget trusts MainScreen and renders when called (no duplicate checks)
+/// - This approach works cleanly with Strategy Pattern (both ad types use same state)
 /// 
 /// **UI Features:**
 /// - "ADVERTISEMENT" label (top-right corner)
@@ -79,6 +85,21 @@ class _AdsWidgetState extends ConsumerState<AdsWidget> {
       // Initialize strategy (this also loads the initial ad)
       await _strategy!.initialize(ref);
 
+      // Trigger rebuild to show the ad
+      if (mounted && !_isDisposed) {
+        setState(() {});
+      }
+      
+      // Check current connection state and start countdown if already connected
+      final currentConnectionState = ref.read(connectionStateProvider).status;
+      if (currentConnectionState == ConnectionStatus.connected) {
+        final adsState = ref.read(adsProvider);
+        if (adsState.nativeAdIsLoaded) {
+          debugPrint('⏰ Already connected on init - starting countdown');
+          ref.read(adsProvider.notifier).startCountdownTimer();
+        }
+      }
+      
       // Listen to connection changes and delegate to strategy
       ref.listenManual(connectionStateProvider, (previous, next) {
         if (_strategy == null || _isDisposed) return;
@@ -106,23 +127,18 @@ class _AdsWidgetState extends ConsumerState<AdsWidget> {
   Widget build(BuildContext context) {
     final adsState = ref.watch(adsProvider);
 
-    // Hide ad panel completely if loading failed (don't show errors to users)
+    // Safety check: Hide if loading failed (MainScreen should already handle this)
     if (adsState.adLoadFailed) {
       return const SizedBox.shrink();
     }
 
-    // For internal ads: Don't show container until we have a valid image URL
-    if (_useInternalAds) {
-      if (adsState.customImageUrl == null || adsState.customImageUrl!.isEmpty) {
-        return const SizedBox.shrink();
-      }
-    }
-
-    // For Google ads: Don't show container until ad is actually loaded
-    if (!_useInternalAds && !adsState.nativeAdIsLoaded) {
+    // Wait for strategy to initialize (happens in postFrameCallback)
+    if (_strategy == null) {
       return const SizedBox.shrink();
     }
 
+    // Render ad container - MainScreen controls visibility via shouldShowAd
+    // No need to check ad loaded state here, MainScreen already does that
     return SizedBox(
       height: 280.h,
       width: 336.w,