check for updates - initial implementation.

GUI/GarUpdate.cs

@@ -0,0 +1,197 @@
+//! \file       GarUpdate.cs
+//! \date       Tue Feb 14 00:02:14 2017
+//! \brief      Application update routines.
+//
+// Copyright (C) 2017 by morkt
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Net;
+using System.Linq;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Input;
+using System.Xml;
+using GameRes;
+
+namespace GARbro.GUI
+{
+    public partial class MainWindow : Window
+    {
+        private readonly BackgroundWorker m_update_checker = new BackgroundWorker();
+
+        private void InitUpdatesChecker ()
+        {
+            m_update_checker.DoWork += StartUpdatesCheck;
+            m_update_checker.RunWorkerCompleted += UpdatesCheckComplete;
+        }
+
+        /// <summary>
+        /// Handle "Check for updates" command.
+        /// </summary>
+        private void CheckUpdatesExec (object sender, ExecutedRoutedEventArgs e)
+        {
+            if (!m_update_checker.IsBusy)
+                m_update_checker.RunWorkerAsync();
+        }
+
+        private void StartUpdatesCheck (object sender, DoWorkEventArgs e)
+        {
+            var url = m_app.Resources["UpdateUrl"] as Uri;
+            if (null == url)
+                return;
+            using (var updater = new GarUpdate (this))
+            {
+                e.Result = updater.Check (url);
+            }
+        }
+
+        private void UpdatesCheckComplete (object sender, RunWorkerCompletedEventArgs e)
+        {
+            if (e.Error != null)
+            {
+                SetStatusText (string.Format ("{0} {1}", "Update failed.", e.Error.Message));
+                return;
+            }
+            else if (e.Cancelled)
+                return;
+            var result = e.Result as GarUpdateInfo;
+            if (null == result)
+            {
+                SetStatusText ("No updates currently available.");
+                return;
+            }
+            var app_version = Assembly.GetExecutingAssembly().GetName().Version;
+            var db_version = FormatCatalog.Instance.CurrentSchemeVersion;
+            bool has_app_update = app_version < result.ReleaseVersion;
+            bool has_db_update = db_version < result.FormatsVersion && CheckAssemblies (result.Assemblies);
+            if (!has_app_update && !has_db_update)
+            {
+                SetStatusText ("GARbro version is up to date.");
+                return;
+            }
+            var dialog = new UpdateDialog (result, has_app_update, has_db_update);
+            dialog.Owner = this;
+            dialog.FormatsDownload.Click = FormatsDownloadExec;
+            dialog.ShowDialog();
+        }
+
+        private void FormatsDownloadExec (object sender, RoutedEventArgs e)
+        {
+        }
+
+        /// <summary>
+        /// Check if loaded assemblies match required versions.
+        /// </summary>
+        bool CheckAssemblies (IDictionary<string, Version> assemblies)
+        {
+            var loaded = AppDomain.CurrentDomain.GetAssemblies().Select (a => a.GetName())
+                         .ToDictionary (a => a.Name, a => a.Version);
+            foreach (var item in assemblies)
+            {
+                if (!loaded.ContainsKey (item.Key))
+                    return false;
+                if (loaded[item.Key] < item.Value)
+                    return false;
+            }
+            return true;
+        }
+    }
+
+    public class GarUpdateInfo
+    {
+        public Version  ReleaseVersion { get; set; }
+        public Uri          ReleaseUrl { get; set; }
+        public string     ReleaseNotes { get; set; }
+        public int      FormatsVersion { get; set; }
+        public Uri          FormatsUrl { get; set; }
+        public IDictionary<string, Version> Assemblies { get; set; }
+    }
+
+    internal sealed class GarUpdate : IDisposable
+    {
+        Window      m_main;
+
+        const int RequestTimeout = 20000; // milliseconds
+
+        public GarUpdate (Window main)
+        {
+            m_main = main;
+        }
+
+        public GarUpdateInfo Check (Uri version_url)
+        {
+            var request = WebRequest.Create (version_url);
+            request.Timeout = RequestTimeout;
+            var response = (HttpWebResponse)request.GetResponse();
+            using (var input = response.GetResponseStream())
+            {
+                var xml = new XmlDocument();
+                xml.Load (input);
+                var root = xml.DocumentElement.SelectSingleNode ("/GARbro");
+                if (null == root)
+                    return null;
+                var info = new GarUpdateInfo
+                {
+                    ReleaseVersion = Version.Parse (GetInnerText (root.SelectSingleNode ("Release/Version"))),
+                    ReleaseUrl = new Uri (GetInnerText (root.SelectSingleNode ("Release/Url"))),
+                    ReleaseNotes = GetInnerText (root.SelectSingleNode ("Release/Notes")),
+
+                    FormatsVersion = Int32.Parse (GetInnerText (root.SelectSingleNode ("FormatsData/FileVersion"))),
+                    FormatsUrl = new Uri (GetInnerText (root.SelectSingleNode ("FormatsData/Url"))),
+                    Assemblies = ParseAssemblies (root.SelectNodes ("FormatsData/Requires/Assembly")),
+                };
+                return info;
+            }
+        }
+
+        static string GetInnerText (XmlNode node)
+        {
+            return node != null ? node.InnerText : "";
+        }
+
+        IDictionary<string, Version> ParseAssemblies (XmlNodeList nodes)
+        {
+            var dict = new Dictionary<string, Version>();
+            foreach (XmlNode node in nodes)
+            {
+                var attr = node.Attributes;
+                var name = attr["Name"];
+                var version = attr["Version"];
+                if (name != null && version != null)
+                    dict[name.Value] = Version.Parse (version.Value);
+            }
+            return dict;
+        }
+
+        bool m_disposed = false;
+        public void Dispose ()
+        {
+            if (!m_disposed)
+            {
+                m_disposed = true;
+            }
+            GC.SuppressFinalize (this);
+        }
+    }
+}