Refactor WaitForInternetConnection async so it doesn't depend on Pings (issues with certain firewalls)

Author: marticliment

src/Directory.Build.props

@@ -2,7 +2,7 @@
     <PropertyGroup>
         <ImplicitUsings>enable</ImplicitUsings>
         <TargetPlatformMinVersion>10.0.19041.0</TargetPlatformMinVersion>
-        <WindowsSdkPackageVersion>10.0.26100.56</WindowsSdkPackageVersion>
+        <WindowsSdkPackageVersion>10.0.26100.57</WindowsSdkPackageVersion>
         <SdkVersion>8.0.405</SdkVersion>
         <Authors>Martí Climent and the contributors</Authors>
         <PublisherName>Martí Climent</PublisherName>

src/UniGetUI.Core.Classes/TaskRecycler.cs

@@ -19,9 +19,16 @@ namespace UniGetUI.Core.Classes;
 public static class TaskRecycler<ReturnT>
 {
     private static readonly ConcurrentDictionary<int, Task<ReturnT>> _tasks = new();
+    private static readonly ConcurrentDictionary<int, Task> _tasks_VOID = new();
 
     // ---------------------------------------------------------------------------------------------------------------
 
+    public static Task RunOrAttachAsync_VOID(Action method, int cacheTimeSecs = 0)
+    {
+        int hash = method.GetHashCode();
+        return _runTaskAndWait_VOID(new Task(method), hash, cacheTimeSecs);
+    }
+
     /// Asynchronous entry point for 0 parameters
     public static Task<ReturnT> RunOrAttachAsync(Func<ReturnT> method, int cacheTimeSecs = 0)
     {
@@ -86,6 +93,37 @@ public static void RemoveFromCache(Func<ReturnT> method)
 
     // ---------------------------------------------------------------------------------------------------------------
 
+
+    /// <summary>
+    /// Handles running the task if no such task was found on cache, and returning the cached task if it was found.
+    /// </summary>
+    private static async Task _runTaskAndWait_VOID(Task task, int hash, int cacheTimeSecsSecs)
+    {
+        if (_tasks_VOID.TryGetValue(hash, out Task? _task))
+        {
+            // Get the cached task, which is either running or finished
+            task = _task;
+        }
+        else if (!_tasks_VOID.TryAdd(hash, task))
+        {
+            // Race condition, an equivalent task got added from another thread between the TryGetValue and TryAdd,
+            // so we are going to restart the call to _runTaskAndWait in order for TryGetValue to return the new task again
+            await _runTaskAndWait_VOID(task, hash, cacheTimeSecsSecs);
+            return;
+        }
+        else
+        {
+            // Now that the new task is in the cache, run the task.
+            task.Start();
+        }
+
+        // Wait for the task to finish
+        await task;
+
+        // Schedule the task for removal after the cache time expires
+        _removeFromCache(hash, cacheTimeSecsSecs);
+    }
+
     /// <summary>
     /// Handles running the task if no such task was found on cache, and returning the cached task if it was found.
     /// </summary>

src/UniGetUI.Core.Tools/Tools.cs

@@ -6,6 +6,7 @@
 using System.Security.Cryptography;
 using System.Security.Principal;
 using System.Text;
+using Windows.Networking.Connectivity;
 using UniGetUI.Core.Classes;
 using UniGetUI.Core.Data;
 using UniGetUI.Core.Language;
@@ -639,42 +640,27 @@ public static ProcessStartInfo UpdateEnvironmentVariables(ProcessStartInfo info)
         /// Pings the update server and 3 well-known sites to check for internet availability
         /// </summary>
         public static async Task WaitForInternetConnection()
-            => await (await TaskRecycler<Task>.RunOrAttachAsync(_waitForInternetConnection));
+            => await TaskRecycler<int>.RunOrAttachAsync_VOID(_waitForInternetConnection);
 
-        public static async Task _waitForInternetConnection()
+        public static void _waitForInternetConnection()
         {
             if (Settings.Get("DisableWaitForInternetConnection")) return;
 
-            Logger.Debug("Checking for internet connectivity. Pinging google.com, microsoft.com, couldflare.com and marticliment.com");
-            string[] hosts = ["google.com", "microsoft.com", "cloudflare.com", "github.com"];
-            while (true)
+            Logger.Debug("Checking for internet connectivity...");
+            bool internetLost = false;
+
+            var profile = NetworkInformation.GetInternetConnectionProfile();
+            while (profile is null || profile.GetNetworkConnectivityLevel() is not NetworkConnectivityLevel.InternetAccess)
             {
-                foreach (var host in hosts)
+                Thread.Sleep(1000);
+                profile = NetworkInformation.GetInternetConnectionProfile();
+                if (!internetLost)
                 {
-                    using (var pinger = new Ping())
-                    {
-                        try
-                        {
-                            PingReply reply = await pinger.SendPingAsync(host, 10);
-                            if (reply.Status is IPStatus.Success)
-                            {
-                                Logger.Debug(
-                                    $"{host} responded successfully to ping, internet connection was validated.");
-                                return;
-                            }
-
-                            Logger.Debug($"Could not ping {host}!");
-                        }
-                        catch (Exception ex)
-                        {
-                            Logger.Debug(
-                                $"Could not ping {host} with error {ex.Message}. Are you connected to the internet?");
-                        }
-                    }
+                    Logger.Warn("User is not connected to the internet, waiting for an internet connectio to be available...");
+                    internetLost = true;
                 }
-
-                await Task.Delay(TimeSpan.FromSeconds(5));
             }
+            Logger.Debug("Internet connectivity was established.");
         }
 
         public static string TextProgressGenerator(int length, int progressPercent, string? extra)