Update

DataUtils/Download.cs

@@ -0,0 +1,270 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Threading;
+using System.Reflection;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using Newtonsoft.Json;
+
+namespace DataUtils
+{
+	[ComVisible (false)]
+	public sealed class DownloadHelper
+	{
+		private static readonly object s_downloadLock = new object (); // mimic g_download_cs
+
+		// Public static entry (starts background thread)
+		public static void DownloadFile (string httpUrl, string savePath, object onProgress, object onComplete, object onError)
+		{
+			if (string.IsNullOrEmpty (httpUrl)) throw new ArgumentNullException ("httpUrl");
+			if (string.IsNullOrEmpty (savePath)) throw new ArgumentNullException ("savePath");
+
+			var helper = new DownloadHelper (httpUrl, savePath, onProgress, onComplete, onError);
+			Thread th = new Thread (helper.Worker);
+			th.IsBackground = true;
+			th.Start ();
+		}
+
+		// Instance members
+		private readonly string _url;
+		private readonly string _savePath;
+		private readonly object _cbProgress;
+		private readonly object _cbComplete;
+		private readonly object _cbError;
+
+		private DownloadHelper (string url, string savePath, object cbProgress, object cbComplete, object cbError)
+		{
+			_url = url;
+			_savePath = savePath;
+			_cbProgress = cbProgress;
+			_cbComplete = cbComplete;
+			_cbError = cbError;
+		}
+
+		private void Worker ()
+		{
+			// Single download at a time (mimic CreateScopedLock)
+			lock (s_downloadLock)
+			{
+				HttpWebRequest request = null;
+				HttpWebResponse response = null;
+				Stream responseStream = null;
+				FileStream fileStream = null;
+
+				try
+				{
+					request = (HttpWebRequest)WebRequest.Create (_url);
+					request.Method = "GET";
+					request.AllowAutoRedirect = true;
+					request.UserAgent = "Mozilla/5.0 (Windows NT 6.2; Win32; x86) AppInstallerUpdater/1.0";
+					request.Timeout = 60000; // 60s connect timeout
+					request.ReadWriteTimeout = 60000;
+
+					response = (HttpWebResponse)request.GetResponse ();
+					long contentLength = -1;
+					try { contentLength = response.ContentLength; } catch { contentLength = -1; }
+
+					responseStream = response.GetResponseStream ();
+
+					// create directory if needed
+					string dir = Path.GetDirectoryName (_savePath);
+					if (!string.IsNullOrEmpty (dir) && !Directory.Exists (dir))
+						Directory.CreateDirectory (dir);
+
+					fileStream = new FileStream (_savePath, FileMode.Create, FileAccess.Write, FileShare.Read);
+
+					byte [] buffer = new byte [8192];
+					int bytesRead;
+					long received = 0;
+
+					var lastCheck = DateTime.UtcNow;
+					long lastBytes = 0;
+					const double reportIntervalSeconds = 0.5;
+
+					while ((bytesRead = SafeRead (responseStream, buffer, 0, buffer.Length)) > 0)
+					{
+						fileStream.Write (buffer, 0, bytesRead);
+						received += bytesRead;
+
+						var now = DateTime.UtcNow;
+						double interval = (now - lastCheck).TotalSeconds;
+						long speed = -1;
+						if (interval >= reportIntervalSeconds)
+						{
+							long bytesInInterval = received - lastBytes;
+							if (interval > 0)
+								speed = (long)(bytesInInterval / interval); // B/s
+							lastCheck = now;
+							lastBytes = received;
+						}
+
+						ReportProgress (received, contentLength >= 0 ? contentLength : 0, speed);
+					}
+
+					// flush and close file
+					fileStream.Flush ();
+
+					ReportComplete (_savePath, received);
+				}
+				catch (WebException wex)
+				{
+					string reason = BuildWebExceptionReason (wex);
+					ReportError (_savePath, reason);
+				}
+				catch (Exception ex)
+				{
+					ReportError (_savePath, ex.Message ?? ex.ToString ());
+				}
+				finally
+				{
+					try { if (responseStream != null) responseStream.Close (); } catch { }
+					try { if (response != null) response.Close (); } catch { }
+					try { if (fileStream != null) fileStream.Close (); } catch { }
+				}
+			}
+		}
+
+		// Safe read wrapper to handle potential stream interruptions
+		private static int SafeRead (Stream s, byte [] buffer, int offset, int count)
+		{
+			try
+			{
+				return s.Read (buffer, offset, count);
+			}
+			catch
+			{
+				return 0;
+			}
+		}
+
+		// Build a user-friendly reason text from WebException (includes status / inner messages)
+		private static string BuildWebExceptionReason (WebException wex)
+		{
+			try
+			{
+				StringBuilder sb = new StringBuilder ();
+				sb.Append ("WebException: ");
+				sb.Append (wex.Status.ToString ());
+				if (wex.Response != null)
+				{
+					try
+					{
+						var resp = (HttpWebResponse)wex.Response;
+						sb.AppendFormat (CultureInfo.InvariantCulture, " (HTTP {0})", (int)resp.StatusCode);
+					}
+					catch { }
+				}
+				if (!string.IsNullOrEmpty (wex.Message))
+				{
+					sb.Append (" - ");
+					sb.Append (wex.Message);
+				}
+				return sb.ToString ();
+			}
+			catch
+			{
+				return wex.Message ?? "Unknown WebException";
+			}
+		}
+
+		// ---------- Reporting helpers (use Newtonsoft.Json) ----------
+
+		private void ReportProgress (long received, long total, long speed)
+		{
+			if (_cbProgress == null) return;
+
+			double progress = 0.0;
+			if (total > 0) progress = received / (double)total * 100.0;
+
+			var payload = new
+			{
+				received = received,
+				total = total,
+				speed = FormatSpeed (speed),
+				progress = progress
+			};
+
+			string json = JsonConvert.SerializeObject (payload);
+			CallJS (_cbProgress, json);
+		}
+
+		private void ReportComplete (string file, long size)
+		{
+			if (_cbComplete == null) return;
+
+			var payload = new
+			{
+				file = file ?? string.Empty,
+				status = "ok",
+				size = size
+			};
+
+			string json = JsonConvert.SerializeObject (payload);
+			CallJS (_cbComplete, json);
+		}
+
+		private void ReportError (string file, string reason)
+		{
+			if (_cbError == null) return;
+
+			var payload = new
+			{
+				file = file ?? string.Empty,
+				status = "failed",
+				reason = reason ?? string.Empty
+			};
+
+			string json = JsonConvert.SerializeObject (payload);
+			CallJS (_cbError, json);
+		}
+
+		// Call JS callback object: invoke its "call" method like original code: jsFunc.call(1, arg)
+		private void CallJS (object jsFunc, string arg)
+		{
+			if (jsFunc == null) return;
+			try
+			{
+				// Use reflection to invoke `call` method with (thisArg, arg)
+				jsFunc.GetType ().InvokeMember (
+					"call",
+					BindingFlags.InvokeMethod,
+					null,
+					jsFunc,
+					new object [] { 1, arg });
+			}
+			catch
+			{
+				// ignore errors in callback invocation
+			}
+		}
+
+		// Format speed like original: B/s, KB/s, MB/s, …
+		private string FormatSpeed (long speed)
+		{
+			if (speed < 0) return "--/s";
+			string [] units = new string [] { "B/s", "KB/s", "MB/s", "GB/s", "TB/s" };
+			double s = (double)speed;
+			int idx = 0;
+			while (s >= 1024.0 && idx < units.Length - 1)
+			{
+				s /= 1024.0;
+				idx++;
+			}
+			return string.Format (CultureInfo.InvariantCulture, "{0:0.##} {1}", s, units [idx]);
+		}
+	}
+
+	// Simple COM-visible wrapper class for JS/COM consumers
+	[ComVisible (true)]
+	[ClassInterface (ClassInterfaceType.AutoDual)]
+	public class _I_Download
+	{
+		// Keep method order and names similar to your C++/CLI _I_Download.WorkAsync
+		public void WorkAsync (string httpurl, string saveFilePath, object onComplete, object onError, object onProgress)
+		{
+			DownloadHelper.DownloadFile (httpurl, saveFilePath, onProgress, onComplete, onError);
+		}
+	}
+}