Refresh drives list when mounting/unmounting ISO file (#2406)

Author: gave92

Common/DeviceEvent.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Files.Common
+{
+    public enum DeviceEvent
+    {
+        Added,
+        Removed,
+        Inserted,
+        Ejected
+    }
+}

Files.Launcher/DeviceWatcher.cs

@@ -0,0 +1,94 @@
+using Files.Common;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Management;
+using System.Text;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.AppService;
+using Windows.Foundation.Collections;
+
+namespace FilesFullTrust
+{
+    public class DeviceWatcher : IDisposable
+    {
+        private ManagementEventWatcher insertWatcher, removeWatcher, modifyWatcher;
+        private AppServiceConnection connection;
+
+        private const string WpdGuid = "{6ac27878-a6fa-4155-ba85-f98f491d4f33}";
+
+        public DeviceWatcher(AppServiceConnection connection)
+        {
+            this.connection = connection;
+        }
+
+        public void Start()
+        {
+            WqlEventQuery insertQuery = new WqlEventQuery("SELECT * FROM __InstanceCreationEvent WITHIN 1 WHERE TargetInstance ISA 'Win32_LogicalDisk'");
+            insertWatcher = new ManagementEventWatcher(insertQuery);
+            insertWatcher.EventArrived += new EventArrivedEventHandler(DeviceInsertedEvent);
+            insertWatcher.Start();
+
+            WqlEventQuery modifyQuery = new WqlEventQuery("SELECT * FROM __InstanceModificationEvent WITHIN 1 WHERE TargetInstance ISA 'Win32_LogicalDisk' and TargetInstance.DriveType = 5");
+            modifyWatcher = new ManagementEventWatcher(modifyQuery);
+            modifyWatcher.EventArrived += new EventArrivedEventHandler(DeviceModifiedEvent);
+            modifyWatcher.Start();
+
+            WqlEventQuery removeQuery = new WqlEventQuery("SELECT * FROM __InstanceDeletionEvent WITHIN 1 WHERE TargetInstance ISA 'Win32_LogicalDisk'");
+            removeWatcher = new ManagementEventWatcher(removeQuery);
+            removeWatcher.EventArrived += new EventArrivedEventHandler(DeviceRemovedEvent);
+            removeWatcher.Start();
+        }
+
+        private async void DeviceModifiedEvent(object sender, EventArrivedEventArgs e)
+        {
+            ManagementBaseObject obj = (ManagementBaseObject)e.NewEvent["TargetInstance"];
+            var deviceName = (string)obj.Properties["Name"].Value;
+            var deviceId = (string)obj.Properties["DeviceID"].Value;
+            var volumeName = (string)obj.Properties["VolumeName"].Value;
+            var eventType = volumeName != null ? DeviceEvent.Inserted : DeviceEvent.Ejected;
+            System.Diagnostics.Debug.WriteLine($"Drive modify event: {deviceName}, {deviceId}, {eventType}");
+            await SendEvent(deviceName, deviceId, eventType);
+        }
+
+        private async void DeviceRemovedEvent(object sender, EventArrivedEventArgs e)
+        {
+            ManagementBaseObject obj = (ManagementBaseObject)e.NewEvent["TargetInstance"];
+            var deviceName = (string)obj.Properties["Name"].Value;
+            var deviceId = (string)obj.Properties["DeviceID"].Value;
+            System.Diagnostics.Debug.WriteLine($"Drive removed event: {deviceName}, {deviceId}");
+            await SendEvent(deviceName, deviceId, DeviceEvent.Removed);
+        }
+
+        private async void DeviceInsertedEvent(object sender, EventArrivedEventArgs e)
+        {
+            ManagementBaseObject obj = (ManagementBaseObject)e.NewEvent["TargetInstance"];
+            var deviceName = (string)obj.Properties["Name"].Value;
+            var deviceId = (string)obj.Properties["DeviceID"].Value;
+            System.Diagnostics.Debug.WriteLine($"Drive added event: {deviceName}, {deviceId}");
+            await SendEvent(deviceName, deviceId, DeviceEvent.Added);
+        }
+
+        private async Task SendEvent(string deviceName, string deviceId, DeviceEvent eventType)
+        {
+            if (connection != null)
+            {
+                await connection.SendMessageAsync(new ValueSet()
+                {
+                    { "DeviceID", deviceId },
+                    { "EventType", (int)eventType }
+                });
+            }
+        }
+
+        public void Dispose()
+        {
+            insertWatcher?.Dispose();
+            removeWatcher?.Dispose();
+            modifyWatcher?.Dispose();
+            insertWatcher = null;
+            removeWatcher = null;
+            modifyWatcher = null;
+        }
+    }
+}

Files.Launcher/Files.Launcher.csproj

@@ -116,6 +116,7 @@
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Management" />
     <Reference Include="System.Runtime" />
     <Reference Include="System.Runtime.InteropServices" />
     <Reference Include="System.Threading.Thread" />
@@ -130,6 +131,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="DeviceWatcher.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="QuickLook.cs" />

Files.Launcher/Program.cs

@@ -59,7 +59,7 @@ private static void Main(string[] args)
 
                 // Create filesystem watcher to monitor recycle bin folder(s)
                 // SHChangeNotifyRegister only works if recycle bin is open in explorer :(
-                watchers = new List<FileSystemWatcher>();
+                binWatchers = new List<FileSystemWatcher>();
                 var sid = System.Security.Principal.WindowsIdentity.GetCurrent().User.ToString();
                 foreach (var drive in DriveInfo.GetDrives())
                 {
@@ -77,28 +77,35 @@ private static void Main(string[] args)
                     watcher.Created += Watcher_Changed;
                     watcher.Deleted += Watcher_Changed;
                     watcher.EnableRaisingEvents = true;
-                    watchers.Add(watcher);
+                    binWatchers.Add(watcher);
                 }
 
                 // Preload context menu for better performace
                 // We query the context menu for the app's local folder
                 var preloadPath = ApplicationData.Current.LocalFolder.Path;
                 using var _ = Win32API.ContextMenu.GetContextMenuForFiles(new string[] { preloadPath }, Shell32.CMF.CMF_NORMAL | Shell32.CMF.CMF_SYNCCASCADEMENU, FilterMenuItems(false));
 
-                // Connect to app service and wait until the connection gets closed
+                // Initialize app service
                 appServiceExit = new AutoResetEvent(false);
                 InitializeAppServiceConnection();
+
+                // Initialize device watcher
+                deviceWatcher = new DeviceWatcher(connection);
+                deviceWatcher.Start();
+
+                // Wait until the connection gets closed
                 appServiceExit.WaitOne();
             }
             finally
             {
                 connection?.Dispose();
-                foreach (var watcher in watchers)
+                foreach (var watcher in binWatchers)
                 {
                     watcher.Dispose();
                 }
                 handleTable?.Dispose();
                 recycler?.Dispose();
+                deviceWatcher?.Dispose();
                 appServiceExit?.Dispose();
                 mutex?.ReleaseMutex();
             }
@@ -141,7 +148,8 @@ private static async void Watcher_Changed(object sender, FileSystemEventArgs e)
         private static AutoResetEvent appServiceExit;
         private static ShellFolder recycler;
         private static Win32API.DisposableDictionary handleTable;
-        private static IList<FileSystemWatcher> watchers;
+        private static IList<FileSystemWatcher> binWatchers;
+        private static DeviceWatcher deviceWatcher;
 
         private static async void InitializeAppServiceConnection()
         {

Files/Filesystem/DriveItem.cs

@@ -16,14 +16,34 @@ public class DriveItem : ObservableObject, INavigationControlItem
     {
         public string Glyph { get; set; }
         public string Path { get; set; }
+        public string DeviceID { get; set; }
         public StorageFolder Root { get; set; }
         public NavigationControlItemType ItemType { get; set; } = NavigationControlItemType.Drive;
-        public ByteSize MaxSpace { get; set; }
-        public ByteSize FreeSpace { get; set; }
-        public ByteSize SpaceUsed { get; set; }
         public Visibility ItemVisibility { get; set; } = Visibility.Visible;
         public bool IsRemovable { get; set; }
 
+        private ByteSize maxSpace;
+        private ByteSize freeSpace;
+        private ByteSize spaceUsed;
+
+        public ByteSize MaxSpace
+        {
+            get => maxSpace;
+            set => SetProperty(ref maxSpace, value);
+        }
+
+        public ByteSize FreeSpace
+        {
+            get => freeSpace;
+            set => SetProperty(ref freeSpace, value);
+        }
+
+        public ByteSize SpaceUsed
+        {
+            get => spaceUsed;
+            set => SetProperty(ref spaceUsed, value);
+        }
+
         private DriveType type;
 
         public DriveType Type
@@ -57,22 +77,22 @@ public DriveItem()
             ItemType = NavigationControlItemType.OneDrive;
         }
 
-        public DriveItem(StorageFolder root, DriveType type)
+        public DriveItem(StorageFolder root, string deviceId, DriveType type)
         {
             Text = root.DisplayName;
             Type = type;
             Path = string.IsNullOrEmpty(root.Path) ? $"\\\\?\\{root.Name}\\" : root.Path;
+            DeviceID = deviceId;
             Root = root;
             IsRemovable = (Type == DriveType.Removable || Type == DriveType.CDRom);
 
-            CoreApplication.MainView.ExecuteOnUIThreadAsync(() => GetDriveItemProperties());
+            CoreApplication.MainView.ExecuteOnUIThreadAsync(() => UpdatePropertiesAsync());
         }
 
-        public async Task UpdateAsync()
+        public async Task UpdateLabelAsync()
         {
             try
             {
-                // Delay is needed to apply the new name
                 var properties = await Root.Properties.RetrievePropertiesAsync(new[] { "System.ItemNameDisplay" })
                     .AsTask().WithTimeoutAsync(TimeSpan.FromSeconds(5));
                 Text = (string)properties["System.ItemNameDisplay"];
@@ -82,7 +102,7 @@ public async Task UpdateAsync()
             }
         }
 
-        private async void GetDriveItemProperties()
+        public async Task UpdatePropertiesAsync()
         {
             try
             {
@@ -101,6 +121,7 @@ private async void GetDriveItemProperties()
             catch (NullReferenceException)
             {
                 SpaceText = "DriveCapacityUnknown".GetLocalized();
+                SpaceUsed = ByteSize.FromBytes(0);
             }
         }