Code Quality: Sync the jump list with Explorer

src/Files.App.BackgroundTasks/Files.App.BackgroundTasks.csproj

@@ -24,4 +24,8 @@
         <PackageReference Include="Microsoft.Windows.CsWinRT" />
     </ItemGroup>
 
+    <ItemGroup>
+      <ProjectReference Include="..\Files.App.Storage\Files.App.Storage.csproj" />
+    </ItemGroup>
+
 </Project>

src/Files.App.BackgroundTasks/UpdateTask.cs

@@ -1,13 +1,11 @@
 // Copyright (c) Files Community
 // Licensed under the MIT License.
 
-using System;
+using Files.App.Storage;
 using System.IO;
-using System.Linq;
 using System.Threading.Tasks;
 using Windows.ApplicationModel.Background;
 using Windows.Storage;
-using Windows.UI.StartScreen;
 
 namespace Files.App.BackgroundTasks
 {
@@ -19,8 +17,8 @@ private async Task RunAsync(IBackgroundTaskInstance taskInstance)
 		{
 			var deferral = taskInstance.GetDeferral();
 
-			// Refresh jump list to update string resources
-			try { await RefreshJumpListAsync(); } catch { }
+			// Sync the jump list with Explorer
+			try { RefreshJumpList(); } catch { }
 
 			// Delete previous version log files
 			try { DeleteLogFiles(); } catch { }
@@ -34,30 +32,18 @@ private void DeleteLogFiles()
 			File.Delete(Path.Combine(ApplicationData.Current.LocalFolder.Path, "debug_fulltrust.log"));
 		}
 
-		private async Task RefreshJumpListAsync()
+		private void RefreshJumpList()
 		{
-			if (JumpList.IsSupported())
-			{
-				var instance = await JumpList.LoadCurrentAsync();
-				// Disable automatic jumplist. It doesn't work with Files UWP.
-				instance.SystemGroupKind = JumpListSystemGroupKind.None;
-
-				var jumpListItems = instance.Items.ToList();
-
-				// Clear all items to avoid localization issues
-				instance.Items.Clear();
-
-				foreach (var temp in jumpListItems)
-				{
-					var jumplistItem = JumpListItem.CreateWithArguments(temp.Arguments, temp.DisplayName);
-					jumplistItem.Description = jumplistItem.Arguments;
-					jumplistItem.GroupName = "ms-resource:///Resources/JumpListRecentGroupHeader";
-					jumplistItem.Logo = new Uri("ms-appx:///Assets/FolderIcon.png");
-					instance.Items.Add(jumplistItem);
-				}
-
-				await instance.SaveAsync();
-			}
+			// Make sure to delete the Files' custom destinations binary files
+			var recentFolder = WindowsStorableHelpers.GetRecentFolderPath();
+			File.Delete($"{recentFolder}\\CustomDestinations\\3b19d860a346d7da.customDestinations-ms");
+			File.Delete($"{recentFolder}\\CustomDestinations\\1265066178db259d.customDestinations-ms");
+			File.Delete($"{recentFolder}\\CustomDestinations\\8e2322986488aba5.customDestinations-ms");
+			File.Delete($"{recentFolder}\\CustomDestinations\\6b0bf5ca007c8bea.customDestinations-ms");
+			File.Delete($"{recentFolder}\\AutomaticDestinations\\3b19d860a346d7da.automaticDestinations-ms");
+			File.Delete($"{recentFolder}\\AutomaticDestinations\\1265066178db259d.automaticDestinations-ms");
+			File.Delete($"{recentFolder}\\AutomaticDestinations\\8e2322986488aba5.automaticDestinations-ms");
+			File.Delete($"{recentFolder}\\AutomaticDestinations\\6b0bf5ca007c8bea.automaticDestinations-ms");
 		}
 	}
 }

src/Files.App.CsWin32/ComHeapPtr`1.cs

@@ -7,14 +7,17 @@
 namespace Windows.Win32
 {
 	/// <summary>
-	/// Contains a heap pointer allocated via CoTaskMemAlloc and a set of methods to work with the pointer safely.
+	/// Contains a heap pointer allocated via <see cref="PInvoke.CoTaskMemAlloc"/> and a set of methods to work with the pointer safely.
 	/// </summary>
 	public unsafe struct ComHeapPtr<T> : IDisposable where T : unmanaged
 	{
 		private T* _ptr;
 
-		public bool IsNull
-			=> _ptr == null;
+		public readonly bool IsNull
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			get => _ptr is null;
+		}
 
 		public ComHeapPtr(T* ptr)
 		{
@@ -33,15 +36,44 @@ public ComHeapPtr(T* ptr)
 			return (T**)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
 		}
 
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void Attach(T* ptr)
+		{
+			Dispose();
+			_ptr = ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public T* Detach()
+		{
+			T* ptr = _ptr;
+			_ptr = null;
+			return ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool Allocate(nuint cch)
+		{
+			_ptr = (T*)PInvoke.CoTaskMemAlloc(cch);
+			return _ptr is not null;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool Reallocate(nuint cch)
+		{
+			T* ptr = (T*)PInvoke.CoTaskMemRealloc(_ptr, cch);
+			if (ptr is null) return false;
+			_ptr = ptr;
+			return true;
+		}
+
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public void Dispose()
 		{
 			T* ptr = _ptr;
-			if (ptr is not null)
-			{
-				_ptr = null;
-				PInvoke.CoTaskMemFree((void*)ptr);
-			}
+			if (ptr is null) return;
+			_ptr = null;
+			PInvoke.CoTaskMemFree(ptr);
 		}
 	}
 }

src/Files.App.CsWin32/ComPtr`1.cs

@@ -50,6 +50,15 @@ public void Attach(T* other)
 			return ptr;
 		}
 
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public readonly HRESULT CopyTo(T** ptr)
+		{
+			InternalAddRef();
+			*ptr = _ptr;
+
+			return HRESULT.S_OK;
+		}
+
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public readonly T* Get()
 		{
@@ -80,6 +89,14 @@ public readonly HRESULT CoCreateInstance(Guid* rclsid, IUnknown* pUnkOuter = nul
 			return PInvoke.CoCreateInstance(rclsid, pUnkOuter, dwClsContext, (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in T.Guid)), (void**)this.GetAddressOf());
 		}
 
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		private readonly void InternalAddRef()
+		{
+			T* ptr = _ptr;
+			if (ptr != null)
+				_ = ((IUnknown*)ptr)->AddRef();
+		}
+
 		// Disposer
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Files.App.CsWin32/HRESULT.cs

@@ -21,5 +21,8 @@ public readonly HRESULT ThrowIfFailedOnDebug()
 
 			return this;
 		}
+
+		// #define E_NOT_SET HRESULT_FROM_WIN32(ERROR_NOT_FOUND)
+		public static readonly HRESULT E_NOT_SET = (HRESULT)(-2147023728);
 	}
 }

src/Files.App.CsWin32/HeapPtr`1.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Windows.Win32
+{
+	/// <summary>
+	/// Contains a heap pointer allocated via <see cref="NativeMemory.Alloc"/> and a set of methods to work with the pointer safely.
+	/// </summary>
+	public unsafe struct HeapPtr<T> : IDisposable where T : unmanaged
+	{
+		private T* _ptr;
+
+		public readonly bool IsNull
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining)]
+			get => _ptr is null;
+		}
+
+		public HeapPtr(T* ptr)
+		{
+			_ptr = ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public readonly T* Get()
+		{
+			return _ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public readonly T** GetAddressOf()
+		{
+			return (T**)Unsafe.AsPointer(ref Unsafe.AsRef(in this));
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void Attach(T* ptr)
+		{
+			Dispose();
+			_ptr = ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public T* Detach()
+		{
+			T* ptr = _ptr;
+			_ptr = null;
+			return ptr;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool Allocate(nuint cch)
+		{
+			_ptr = (T*)NativeMemory.Alloc(cch * (nuint)sizeof(T)); // malloc()
+			return _ptr is not null;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public bool Reallocate(nuint cch)
+		{
+			T* ptr = (T*)NativeMemory.Realloc(_ptr, cch * (nuint)sizeof(T)); // realloc()
+			if (ptr is null) return false;
+			_ptr = ptr;
+			return true;
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public void Dispose()
+		{
+			T* ptr = _ptr;
+			if (ptr is null) return;
+			_ptr = null;
+			NativeMemory.Free(ptr); // free()
+		}
+	}
+}