Merge branch 'dev' into release

Author: goku-kamehameha

lib/app/advertise_director.dart

@@ -1,3 +1,4 @@
+import 'dart:io';
 import 'package:defyx_vpn/core/data/local/secure_storage/secure_storage.dart';
 import 'package:defyx_vpn/core/data/local/secure_storage/secure_storage_const.dart';
 import 'package:flutter_timezone/flutter_timezone.dart';
@@ -11,24 +12,34 @@ class AdvertiseDirector {
   AdvertiseDirector(this.ref);
 
   static Future<bool> shouldUseInternalAds(WidgetRef ref) async {
+    // STRATEGY SELECTION (for backward compatibility with desktop):
+    // - Desktop (Windows/macOS/Linux) → InternalAdStrategy only (no AdMob support)
+    // - Mobile (Android/iOS) → DUAL strategy approach:
+    //     * GoogleAdStrategy handles AdMob ads (disconnected state ONLY)
+    //     * InternalAdStrategy handles internal ads (connected state ONLY)
+    //     * AdsWidget coordinates between the two strategies
+    
+    if (Platform.isWindows || Platform.isMacOS || Platform.isLinux) {
+      debugPrint('📍 Ad Manager - Desktop platform detected, using InternalAdStrategy only');
+      return true;
+    }
+
+    // Mobile platforms use DUAL strategy (GoogleAdStrategy + InternalAdStrategy)
+    // AdsWidget automatically initializes both and routes based on connection state:
+    //   - When CONNECTED: InternalAdStrategy shows internal ads (timezone-specific or General)
+    //   - When DISCONNECTED: GoogleAdStrategy shows AdMob ads
+    debugPrint('📍 Ad Manager - Mobile platform detected, using DUAL strategy approach');
+    
     final String currentTimeZone = await FlutterTimezone.getLocalTimezone();
     debugPrint('📍 Ad Manager - Current Timezone: $currentTimeZone');
-
-    final adversies =
-        await ref.read(secureStorageProvider).readMap(apiAvertiseKey);
-
+    
+    final adversies = await ref.read(secureStorageProvider).readMap(apiAvertiseKey);
     if (adversies['api_advertise'] != null) {
       final advertiseMap = adversies['api_advertise'] as Map<String, dynamic>;
-      final hasInternalAds = advertiseMap.containsKey(currentTimeZone);
-      debugPrint('📍 Ad Manager - Has internal ads for timezone: $hasInternalAds');
-      if (hasInternalAds) {
-        debugPrint('📍 Ad Manager - Available timezones: ${advertiseMap.keys.toList()}');
-      }
-      return hasInternalAds;
+      debugPrint('📍 Ad Manager - Available ad keys: ${advertiseMap.keys.toList()}');
     }
 
-    debugPrint('📍 Ad Manager - No advertise data found');
-    return false;
+    return false; // Mobile uses dual strategy (both GoogleAdStrategy + InternalAdStrategy)
   }
 
   static Future<String> getCustomAdBanner(WidgetRef ref) async {
@@ -50,26 +61,47 @@ class AdvertiseDirector {
 
     if (adversies['api_advertise'] != null) {
       final advertiseMap = adversies['api_advertise'] as Map<String, dynamic>;
+      
+      // Try timezone-specific ads first
       if (advertiseMap.containsKey(currentTimeZone)) {
         final adsData = advertiseMap[currentTimeZone] as List<dynamic>;
-        debugPrint('📍 Ad Manager - Found ${adsData.length} ads for timezone');
+        debugPrint('📍 Ad Manager - Found ${adsData.length} timezone-specific ads');
+        if (adsData.isNotEmpty) {
+          final random = Random();
+          final randomIndex = random.nextInt(adsData.length);
+          final selectedAd = adsData[randomIndex] as List<dynamic>;
+
+          if (selectedAd.length >= 2) {
+            debugPrint('📍 Ad Manager - Selected timezone ad #$randomIndex');
+            return {
+              'imageUrl': selectedAd[0] as String,
+              'clickUrl': selectedAd[1] as String,
+            };
+          }
+        }
+      }
+      
+      // Fallback to "General" ads if no timezone-specific ads
+      if (advertiseMap.containsKey('General')) {
+        final adsData = advertiseMap['General'] as List<dynamic>;
+        debugPrint('📍 Ad Manager - Using "General" fallback ads (${adsData.length} available)');
         if (adsData.isNotEmpty) {
           final random = Random();
           final randomIndex = random.nextInt(adsData.length);
           final selectedAd = adsData[randomIndex] as List<dynamic>;
 
           if (selectedAd.length >= 2) {
-            debugPrint('📍 Ad Manager - Selected ad #$randomIndex');
+            debugPrint('📍 Ad Manager - Selected General ad #$randomIndex');
             return {
               'imageUrl': selectedAd[0] as String,
               'clickUrl': selectedAd[1] as String,
             };
           }
         }
-      } else {
-        debugPrint('📍 Ad Manager - No ads for timezone: $currentTimeZone');
-        debugPrint('📍 Ad Manager - Available timezones: ${advertiseMap.keys.toList()}');
       }
+      
+      debugPrint('📍 Ad Manager - No ads for timezone: $currentTimeZone');
+      debugPrint('📍 Ad Manager - Available keys: ${advertiseMap.keys.toList()}');
     }
 
     debugPrint('📍 Ad Manager - Returning empty ad');

lib/app/app.dart

@@ -47,9 +47,14 @@ class App extends ConsumerWidget {
 
     final shouldUseInternalAds = snapshot.data!;
     if (shouldUseInternalAds) {
-      debugPrint('Using internal ads');
+      debugPrint('📱 Using internal ads (desktop platform or backend config)');
     } else {
-      _initializeMobileAdsWithConsent(ref);
+      // Only initialize AdMob on mobile platforms
+      if (Platform.isAndroid || Platform.isIOS) {
+        _initializeMobileAdsWithConsent(ref);
+      } else {
+        debugPrint('📱 Skipping AdMob initialization on desktop platform');
+      }
     }
   }
 

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

@@ -213,27 +213,11 @@ class _MainScreenState extends ConsumerState<MainScreen> {
                               onSecretTap: _handleSecretTap,
                               onPingRefresh: _logic.refreshPing,
                             ),
-                            SizedBox(
-                              height: connectionState.status ==
-                                      ConnectionStatus.connected
-                                  ? 40.h
-                                  : 80.h,
-                            ),
-                            SizedBox(
-                              height: connectionState.status ==
-                                      ConnectionStatus.connected
-                                  ? 0.24.sh
-                                  : 0.28.sh,
-                            ),
+                            SizedBox(height: 50.h),  // Reduced to raise ads higher
+                            SizedBox(height: 0.16.sh),  // Reduced to raise ads higher
                             _buildContentSection(
                                 connectionState.status, adsState),
-                            SizedBox(
-                              height: connectionState.status ==
-                                          ConnectionStatus.connected &&
-                                      adsState.showCountdown
-                                  ? 140.h
-                                  : 0.15.sh,
-                            ),
+                            SizedBox(height: 0.15.sh),  // Consistent bottom spacing
                           ],
                         ),
                       ],
@@ -275,58 +259,89 @@ class _MainScreenState extends ConsumerState<MainScreen> {
   }
 
   Widget _buildContentSection(ConnectionStatus status, dynamic adsState) {
+    debugPrint('🎨 _buildContentSection called:');
+    debugPrint('   Status: ${status.name}');
+    debugPrint('   nativeAdIsLoaded: ${adsState.nativeAdIsLoaded}');
+    debugPrint('   showCountdown: ${adsState.showCountdown}');
+    debugPrint('   adLoadFailed: ${adsState.adLoadFailed}');
+    
+    // Determine if we should show ads based on state
+    bool shouldShowAd = false;
+    Widget? mainContent;
+    
     switch (status) {
       case ConnectionStatus.noInternet:
         _dinoGame ??= DinoGame();
-        return SizedBox(
+        mainContent = SizedBox(
           height: 200.h,
           child: ClipRRect(
             borderRadius: BorderRadius.circular(16.r),
             child: GameWidget(game: _dinoGame!),
           ),
         );
+        break;
 
       case ConnectionStatus.disconnected:
-        return TipsSliderSection(
-          status: status,
-        );
+        // DISCONNECTED: Show AdMob ad (after VPN use) if available, else show tips
+        final shouldShowAdMobAd = adsState.showCountdown && 
+                                   adsState.nativeAdIsLoaded;
+        
+        debugPrint('   🎯 DISCONNECTED: shouldShowAdMobAd=$shouldShowAdMobAd');
+        
+        if (shouldShowAdMobAd) {
+          debugPrint('   ✅ Rendering AdMob ad');
+          shouldShowAd = true;
+        } else {
+          debugPrint('   ℹ️ Rendering tips slider');
+          mainContent = TipsSliderSection(status: status);
+        }
+        break;
 
       default:
-        // 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;
-
-        return SizedBox(
-          height: 280.h,
-          width: 336.w,
-          child: AnimatedSlide(
-            offset: Offset(
-              0,
-              shouldShowAd ? 0.0 : 1.0,
-            ),
-            duration: _animationService
-                .adjustDuration(const Duration(milliseconds: 800)),
-            curve: Curves.easeOut,
-            child: AnimatedOpacity(
-              opacity: shouldShowAd ? 1.0 : 0.0,
-              duration: _animationService
-                  .adjustDuration(const Duration(milliseconds: 500)),
-              curve: Curves.easeInOut,
-              child: DecoratedBox(
-                decoration: BoxDecoration(
-                  color: const Color(0xFF19312F),
-                  borderRadius: BorderRadius.circular(10.r),
+        // CONNECTED/CONNECTING: Show internal ad (during VPN use) if available
+        final shouldShowInternalAd = adsState.showCountdown && 
+                                      (adsState.customImageUrl?.isNotEmpty ?? false);
+        
+        debugPrint('   🎯 CONNECTED/OTHER: shouldShowInternalAd=$shouldShowInternalAd (hasCustomImage=${adsState.customImageUrl != null})');
+        
+        if (shouldShowInternalAd) {
+          debugPrint('   ✅ Rendering internal ad');
+          shouldShowAd = true;
+        } else {
+          debugPrint('   ⚪ Rendering empty (no ad)');
+          mainContent = const SizedBox.shrink();
+        }
+    }
+    
+    // CRITICAL: Keep AdsWidget in ONE position in the tree to prevent dispose/recreate cycles
+    // Control visibility with Opacity instead of moving widget around
+    return Stack(
+      alignment: Alignment.topCenter,  // Align to top-center for consistent positioning
+      children: [
+        // Always in tree at same position - never recreated
+        Opacity(
+          opacity: shouldShowAd ? 1.0 : 0.0,
+          child: IgnorePointer(
+            ignoring: !shouldShowAd,  // Prevent touch events when hidden
+            child: Padding(
+              padding: EdgeInsets.only(top: 50.h),  // Match the spacing above ads
+              child: SizedBox(
+                height: 280.h,
+                width: 336.w,
+                child: DecoratedBox(
+                  decoration: BoxDecoration(
+                    color: const Color(0xFF19312F),
+                    borderRadius: BorderRadius.circular(10.r),
+                  ),
+                  child: _adsWidget,  // Always same widget instance, same position
                 ),
-                child: _adsWidget,
               ),
             ),
           ),
-        );
-    }
+        ),
+        // Show main content when not showing ad
+        if (!shouldShowAd && mainContent != null) mainContent,
+      ],
+    );
   }
 }