Add 'src/modules/launcher/' from commit '28acd466b352a807910cebbc74477d3173b31511'

git-subtree-dir: src/modules/launcher
git-subtree-mainline: 852689b3df
git-subtree-split: 28acd466b3

src/modules/launcher/Wox.Infrastructure/Image/ImageCache.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Media;
+
+namespace Wox.Infrastructure.Image
+{
+    [Serializable]
+    public class ImageCache
+    {
+        private const int MaxCached = 5000;
+        public ConcurrentDictionary<string, int> Usage = new ConcurrentDictionary<string, int>();
+        private readonly ConcurrentDictionary<string, ImageSource> _data = new ConcurrentDictionary<string, ImageSource>();
+
+
+        public ImageSource this[string path]
+        {
+            get
+            {
+                Usage.AddOrUpdate(path, 1, (k, v) => v + 1);
+                var i = _data[path];
+                return i;
+            }
+            set { _data[path] = value; }
+        }
+
+        public void Cleanup()
+        {
+            var images = Usage
+                .OrderByDescending(o => o.Value)
+                .Take(MaxCached)
+                .ToDictionary(i => i.Key, i => i.Value);
+            Usage = new ConcurrentDictionary<string, int>(images);
+        }
+
+        public bool ContainsKey(string key)
+        {
+            var contains = _data.ContainsKey(key);
+            return contains;
+        }
+
+        public int CacheSize()
+        {
+            return _data.Count;
+        }
+
+        /// <summary>
+        /// return the number of unique images in the cache (by reference not by checking images content)
+        /// </summary>
+        public int UniqueImagesInCache()
+        {
+            return _data.Values.Distinct().Count();
+        }
+    }
+
+}

src/modules/launcher/Wox.Infrastructure/Image/ImageHashGenerator.cs

@@ -0,0 +1,49 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace Wox.Infrastructure.Image
+{
+    public interface IImageHashGenerator
+    {
+        string GetHashFromImage(ImageSource image);
+    }
+    public class ImageHashGenerator : IImageHashGenerator
+    {
+        public string GetHashFromImage(ImageSource imageSource)
+        {
+            if (!(imageSource is BitmapSource image))
+            {
+                return null;
+            }
+
+            try
+            {
+                using (var outStream = new MemoryStream())
+                {
+                    // PngBitmapEncoder enc2 = new PngBitmapEncoder();
+                    // enc2.Frames.Add(BitmapFrame.Create(tt));
+                    
+                    var enc = new JpegBitmapEncoder();
+                    var bitmapFrame = BitmapFrame.Create(image);
+                    bitmapFrame.Freeze();
+                    enc.Frames.Add(bitmapFrame);
+                    enc.Save(outStream);
+                    var byteArray = outStream.GetBuffer();
+                    using (var sha1 = new SHA1CryptoServiceProvider())
+                    {
+                        var hash = Convert.ToBase64String(sha1.ComputeHash(byteArray));
+                        return hash;
+                    }
+                }
+            }
+            catch
+            {
+                return null;
+            }
+
+        }
+    }
+}

src/modules/launcher/Wox.Infrastructure/Image/ImageLoader.cs

@@ -0,0 +1,215 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using Wox.Infrastructure.Logger;
+using Wox.Infrastructure.Storage;
+
+namespace Wox.Infrastructure.Image
+{
+    public static class ImageLoader
+    {
+        private static readonly ImageCache ImageCache = new ImageCache();
+        private static BinaryStorage<ConcurrentDictionary<string, int>> _storage;
+        private static readonly ConcurrentDictionary<string, string> GuidToKey = new ConcurrentDictionary<string, string>();
+        private static IImageHashGenerator _hashGenerator;
+
+
+        private static readonly string[] ImageExtensions =
+        {
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".bmp",
+            ".tiff",
+            ".ico"
+        };
+
+
+        public static void Initialize()
+        {
+            _storage = new BinaryStorage<ConcurrentDictionary<string, int>>("Image");
+            _hashGenerator = new ImageHashGenerator();
+            ImageCache.Usage = _storage.TryLoad(new ConcurrentDictionary<string, int>());
+
+            foreach (var icon in new[] { Constant.DefaultIcon, Constant.ErrorIcon })
+            {
+                ImageSource img = new BitmapImage(new Uri(icon));
+                img.Freeze();
+                ImageCache[icon] = img;
+            }
+            Task.Run(() =>
+            {
+                Stopwatch.Normal("|ImageLoader.Initialize|Preload images cost", () =>
+                {
+                    ImageCache.Usage.AsParallel().ForAll(x =>
+                    {
+                        Load(x.Key);
+                    });
+                });
+                Log.Info($"|ImageLoader.Initialize|Number of preload images is <{ImageCache.Usage.Count}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");
+            });
+        }
+
+        public static void Save()
+        {
+            ImageCache.Cleanup();
+            _storage.Save(ImageCache.Usage);
+        }
+
+        private class ImageResult
+        {
+            public ImageResult(ImageSource imageSource, ImageType imageType)
+            {
+                ImageSource = imageSource;
+                ImageType = imageType;
+            }
+
+            public ImageType ImageType { get; }
+            public ImageSource ImageSource { get; }
+        }
+
+        private enum ImageType
+        {
+            File,
+            Folder,
+            Data,
+            ImageFile,
+            Error,
+            Cache
+        }
+
+        private static ImageResult LoadInternal(string path, bool loadFullImage = false)
+        {
+            ImageSource image;
+            ImageType type = ImageType.Error;
+            try
+            {
+                if (string.IsNullOrEmpty(path))
+                {
+                    return new ImageResult(ImageCache[Constant.ErrorIcon], ImageType.Error);
+                }
+                if (ImageCache.ContainsKey(path))
+                {
+                    return new ImageResult(ImageCache[path], ImageType.Cache);
+                }
+
+                if (path.StartsWith("data:", StringComparison.OrdinalIgnoreCase))
+                {
+                    var imageSource = new BitmapImage(new Uri(path));
+                    imageSource.Freeze();
+                    return new ImageResult(imageSource, ImageType.Data);
+                }
+
+                if (!Path.IsPathRooted(path))
+                {
+                    path = Path.Combine(Constant.ProgramDirectory, "Images", Path.GetFileName(path));
+                }
+
+                if (Directory.Exists(path))
+                {
+                    /* Directories can also have thumbnails instead of shell icons.
+                     * Generating thumbnails for a bunch of folders while scrolling through
+                     * results from Everything makes a big impact on performance and 
+                     * Wox responsibility. 
+                     * - Solution: just load the icon
+                     */
+                    type = ImageType.Folder;
+                    image = WindowsThumbnailProvider.GetThumbnail(path, Constant.ThumbnailSize,
+                        Constant.ThumbnailSize, ThumbnailOptions.IconOnly);
+
+                }
+                else if (File.Exists(path))
+                {
+                    var extension = Path.GetExtension(path).ToLower();
+                    if (ImageExtensions.Contains(extension))
+                    {
+                        type = ImageType.ImageFile;
+                        if (loadFullImage)
+                        {
+                            image = LoadFullImage(path);
+                        }
+                        else
+                        {
+                            /* Although the documentation for GetImage on MSDN indicates that 
+                             * if a thumbnail is available it will return one, this has proved to not
+                             * be the case in many situations while testing. 
+                             * - Solution: explicitly pass the ThumbnailOnly flag
+                             */
+                            image = WindowsThumbnailProvider.GetThumbnail(path, Constant.ThumbnailSize,
+                                Constant.ThumbnailSize, ThumbnailOptions.ThumbnailOnly);
+                        }
+                    }
+                    else
+                    {
+                        type = ImageType.File;
+                        image = WindowsThumbnailProvider.GetThumbnail(path, Constant.ThumbnailSize,
+                            Constant.ThumbnailSize, ThumbnailOptions.None);
+                    }
+                }
+                else
+                {
+                    image = ImageCache[Constant.ErrorIcon];
+                    path = Constant.ErrorIcon;
+                }
+
+                if (type != ImageType.Error)
+                {
+                    image.Freeze();
+                }
+            }
+            catch (System.Exception e)
+            {
+                Log.Exception($"|ImageLoader.Load|Failed to get thumbnail for {path}", e);
+                type = ImageType.Error;
+                image = ImageCache[Constant.ErrorIcon];
+                ImageCache[path] = image;
+            }
+            return new ImageResult(image, type);
+        }
+
+        private static bool EnableImageHash = true;
+
+        public static ImageSource Load(string path, bool loadFullImage = false)
+        {
+            var imageResult = LoadInternal(path, loadFullImage);
+
+            var img = imageResult.ImageSource;
+            if (imageResult.ImageType != ImageType.Error && imageResult.ImageType != ImageType.Cache)
+            { // we need to get image hash
+                string hash = EnableImageHash ? _hashGenerator.GetHashFromImage(img) : null;
+                if (hash != null)
+                {
+                    if (GuidToKey.TryGetValue(hash, out string key))
+                    { // image already exists
+                        img = ImageCache[key];
+                    }
+                    else
+                    { // new guid
+                        GuidToKey[hash] = path;
+                    }
+                }
+
+                // update cache
+                ImageCache[path] = img;
+            }
+
+
+            return img;
+        }
+
+        private static BitmapImage LoadFullImage(string path)
+        {
+            BitmapImage image = new BitmapImage();
+            image.BeginInit();
+            image.CacheOption = BitmapCacheOption.OnLoad;
+            image.UriSource = new Uri(path);
+            image.EndInit();
+            return image;
+        }
+    }
+}

src/modules/launcher/Wox.Infrastructure/Image/ThumbnailReader.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Runtime.InteropServices;
+using System.IO;
+using System.Windows.Interop;
+using System.Windows.Media.Imaging;
+using System.Windows;
+
+namespace Wox.Infrastructure.Image
+{
+    [Flags]
+    public enum ThumbnailOptions
+    {
+        None = 0x00,
+        BiggerSizeOk = 0x01,
+        InMemoryOnly = 0x02,
+        IconOnly = 0x04,
+        ThumbnailOnly = 0x08,
+        InCacheOnly = 0x10,
+    }
+
+    public class WindowsThumbnailProvider
+    {
+        // Based on https://stackoverflow.com/questions/21751747/extract-thumbnail-for-any-file-in-windows
+
+        private const string IShellItem2Guid = "7E9FB0D3-919F-4307-AB2E-9B1860310C93";
+
+        [DllImport("shell32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        internal static extern int SHCreateItemFromParsingName(
+            [MarshalAs(UnmanagedType.LPWStr)] string path,
+            IntPtr pbc,
+            ref Guid riid,
+            [MarshalAs(UnmanagedType.Interface)] out IShellItem shellItem);
+
+        [DllImport("gdi32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool DeleteObject(IntPtr hObject);
+
+        [ComImport]
+        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        [Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe")]
+        internal interface IShellItem
+        {
+            void BindToHandler(IntPtr pbc,
+                [MarshalAs(UnmanagedType.LPStruct)]Guid bhid,
+                [MarshalAs(UnmanagedType.LPStruct)]Guid riid,
+                out IntPtr ppv);
+
+            void GetParent(out IShellItem ppsi);
+            void GetDisplayName(SIGDN sigdnName, out IntPtr ppszName);
+            void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);
+            void Compare(IShellItem psi, uint hint, out int piOrder);
+        };
+
+        internal enum SIGDN : uint
+        {
+            NORMALDISPLAY = 0,
+            PARENTRELATIVEPARSING = 0x80018001,
+            PARENTRELATIVEFORADDRESSBAR = 0x8001c001,
+            DESKTOPABSOLUTEPARSING = 0x80028000,
+            PARENTRELATIVEEDITING = 0x80031001,
+            DESKTOPABSOLUTEEDITING = 0x8004c000,
+            FILESYSPATH = 0x80058000,
+            URL = 0x80068000
+        }
+
+        internal enum HResult
+        {
+            Ok = 0x0000,
+            False = 0x0001,
+            InvalidArguments = unchecked((int)0x80070057),
+            OutOfMemory = unchecked((int)0x8007000E),
+            NoInterface = unchecked((int)0x80004002),
+            Fail = unchecked((int)0x80004005),
+            ExtractionFailed = unchecked((int)0x8004B200),
+            ElementNotFound = unchecked((int)0x80070490),
+            TypeElementNotFound = unchecked((int)0x8002802B),
+            NoObject = unchecked((int)0x800401E5),
+            Win32ErrorCanceled = 1223,
+            Canceled = unchecked((int)0x800704C7),
+            ResourceInUse = unchecked((int)0x800700AA),
+            AccessDenied = unchecked((int)0x80030005)
+        }
+
+        [ComImportAttribute()]
+        [GuidAttribute("bcc18b79-ba16-442f-80c4-8a59c30c463b")]
+        [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
+        internal interface IShellItemImageFactory
+        {
+            [PreserveSig]
+            HResult GetImage(
+            [In, MarshalAs(UnmanagedType.Struct)] NativeSize size,
+            [In] ThumbnailOptions flags,
+            [Out] out IntPtr phbm);
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct NativeSize
+        {
+            private int width;
+            private int height;
+
+            public int Width { set { width = value; } }
+            public int Height { set { height = value; } }
+        };
+
+
+        public static BitmapSource GetThumbnail(string fileName, int width, int height, ThumbnailOptions options)
+        {
+            IntPtr hBitmap = GetHBitmap(Path.GetFullPath(fileName), width, height, options);
+
+            try
+            {
+                return Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
+            }
+            finally
+            {
+                // delete HBitmap to avoid memory leaks
+                DeleteObject(hBitmap);
+            }
+        }
+        
+        private static IntPtr GetHBitmap(string fileName, int width, int height, ThumbnailOptions options)
+        {
+            IShellItem nativeShellItem;
+            Guid shellItem2Guid = new Guid(IShellItem2Guid);
+            int retCode = SHCreateItemFromParsingName(fileName, IntPtr.Zero, ref shellItem2Guid, out nativeShellItem);
+
+            if (retCode != 0)
+                throw Marshal.GetExceptionForHR(retCode);
+
+            NativeSize nativeSize = new NativeSize
+            {
+                Width = width,
+                Height = height
+            };
+
+            IntPtr hBitmap;
+            HResult hr = ((IShellItemImageFactory)nativeShellItem).GetImage(nativeSize, options, out hBitmap);
+
+            // if extracting image thumbnail and failed, extract shell icon
+            if (options == ThumbnailOptions.ThumbnailOnly && hr == HResult.ExtractionFailed)
+            {
+                hr = ((IShellItemImageFactory) nativeShellItem).GetImage(nativeSize, ThumbnailOptions.IconOnly, out hBitmap);
+            }
+
+            Marshal.ReleaseComObject(nativeShellItem);
+
+            if (hr == HResult.Ok) return hBitmap;
+
+            throw new COMException($"Error while extracting thumbnail for {fileName}", Marshal.GetExceptionForHR((int)hr));
+        }
+    }
+}