Add new Helpers + fix WhatsNewDisplayService

taken from CommunityToolkit/Windows#600

Author: Gabboxl

FluentWeather/FluentWeather.csproj

@@ -37,6 +37,7 @@
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.2" />
     <PackageReference Include="CommunityToolkit.Uwp.Controls.Primitives" Version="8.2.251219" />
     <PackageReference Include="CommunityToolkit.Uwp.Controls.Segmented" Version="8.2.251219" />
+    <PackageReference Include="CommunityToolkit.Uwp.Helpers" Version="8.2.251219" />
     <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="10.0.5" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.5" />
     <PackageReference Include="Microsoft.Toolkit.Uwp.Notifications" Version="7.1.3" />

FluentWeather/Services/WhatsNewDisplayService.cs

@@ -3,6 +3,7 @@
 using Windows.ApplicationModel.Core;
 using Windows.UI.Core;
 using FluentWeather.Dialogs;
+using CommunityToolkit.Uwp.Helpers;
 
 namespace FluentWeather.Services
 {
@@ -16,12 +17,12 @@ internal static async Task ShowIfAppropriateAsync()
             await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
                 CoreDispatcherPriority.Normal, async () =>
                 {
-                    //if (SystemInformation.Instance.IsAppUpdated && !shown)
-                    //{
-                    //    shown = true;
-                    //    var dialog = new WhatsNewDialog();
-                    //    await dialog.ShowAsync();
-                    //}
+                    if (SystemInformation.Instance.IsAppUpdated && !shown)
+                    {
+                        shown = true;
+                        var dialog = new WhatsNewDialog();
+                        await dialog.ShowAsync();
+                    }
                 });
         }
     }

FluentWeather/Utils/ApplicationDataStorageHelper.cs

@@ -0,0 +1,321 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using CommunityToolkit.Common.Helpers;
+using Windows.Storage;
+using Windows.System;
+using CommunityToolkit.Helpers;
+
+namespace CommunityToolkit.Uwp.Helpers.ObjectStorage;
+
+/// <summary>
+/// Storage helper for files and folders living in Windows.Storage.ApplicationData storage endpoints.
+/// </summary>
+/// <param name="appData">The data store to interact with.</param>
+/// <param name="objectSerializer">Serializer for converting stored values. Defaults to <see cref="SystemSerializer"/>.</param>
+public partial class ApplicationDataStorageHelper(ApplicationData appData, IObjectSerializer? objectSerializer = null) : ISettingsStorageHelper<string>
+{
+    /// <summary>
+    /// Gets the settings container.
+    /// </summary>
+    public ApplicationDataContainer Settings => AppData.LocalSettings;
+
+    /// <summary>
+    ///  Gets the storage folder.
+    /// </summary>
+    public StorageFolder Folder => AppData.LocalFolder;
+
+    /// <summary>
+    /// Gets the storage host.
+    /// </summary>
+    protected ApplicationData AppData { get; } = appData ?? throw new ArgumentNullException(nameof(appData));
+
+    /// <summary>
+    /// Gets the serializer for converting stored values.
+    /// </summary>
+    protected IObjectSerializer Serializer { get; } = objectSerializer ?? new SystemSerializer();
+
+    /// <summary>
+    /// Get a new instance using ApplicationData.Current and the provided serializer.
+    /// </summary>
+    /// <param name="objectSerializer">Serializer for converting stored values. Defaults to <see cref="SystemSerializer"/>.</param>
+    /// <returns>A new instance of ApplicationDataStorageHelper.</returns>
+    public static ApplicationDataStorageHelper GetCurrent(IObjectSerializer? objectSerializer = null)
+    {
+        var appData = ApplicationData.Current;
+        return new ApplicationDataStorageHelper(appData, objectSerializer);
+    }
+
+#if !HAS_UNO
+    /// <summary>
+    /// Get a new instance using the ApplicationData for the provided user and serializer.
+    /// </summary>
+    /// <param name="user">App data user owner.</param>
+    /// <param name="objectSerializer">Serializer for converting stored values. Defaults to <see cref="SystemSerializer"/>.</param>
+    /// <returns>A new instance of ApplicationDataStorageHelper.</returns>
+    public static async Task<ApplicationDataStorageHelper> GetForUserAsync(User user, IObjectSerializer? objectSerializer = null)
+    {
+        var appData = await ApplicationData.GetForUserAsync(user);
+        return new ApplicationDataStorageHelper(appData, objectSerializer);
+    }
+#endif
+
+    /// <summary>
+    /// Determines whether a setting already exists.
+    /// </summary>
+    /// <param name="key">Key of the setting (that contains object).</param>
+    /// <returns>True if a value exists.</returns>
+    public bool KeyExists(string key)
+    {
+        return Settings.Values.ContainsKey(key);
+    }
+
+    /// <summary>
+    /// Retrieves a single item by its key.
+    /// </summary>
+    /// <typeparam name="T">Type of object retrieved.</typeparam>
+    /// <param name="key">Key of the object.</param>
+    /// <param name="default">Default value of the object.</param>
+    /// <returns>The TValue object.</returns>
+    public T? Read<T>(string key, T? @default = default)
+    {
+        if (Settings.Values.TryGetValue(key, out var valueObj) && valueObj is string valueString)
+        {
+            return Serializer.Deserialize<T>(valueString);
+        }
+
+        return @default;
+    }
+
+    /// <inheritdoc />
+    public bool TryRead<T>(string key, out T? value)
+    {
+        if (Settings.Values.TryGetValue(key, out var valueObj) && valueObj is string valueString)
+        {
+            value = Serializer.Deserialize<T>(valueString);
+            return true;
+        }
+
+        value = default;
+        return false;
+    }
+
+    /// <inheritdoc />
+    public void Save<T>(string key, T value)
+    {
+        Settings.Values[key] = Serializer.Serialize(value);
+    }
+
+    /// <inheritdoc />
+    public bool TryDelete(string key)
+    {
+        return Settings.Values.Remove(key);
+    }
+
+    /// <inheritdoc />
+    public void Clear()
+    {
+        Settings.Values.Clear();
+    }
+
+    /// <summary>
+    /// Determines whether a setting already exists in composite.
+    /// </summary>
+    /// <param name="compositeKey">Key of the composite (that contains settings).</param>
+    /// <param name="key">Key of the setting (that contains object).</param>
+    /// <returns>True if a value exists.</returns>
+    public bool KeyExists(string compositeKey, string key)
+    {
+        if (TryRead(compositeKey, out ApplicationDataCompositeValue? composite) && composite != null)
+        {
+            return composite.ContainsKey(key);
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Attempts to retrieve a single item by its key in composite.
+    /// </summary>
+    /// <typeparam name="T">Type of object retrieved.</typeparam>
+    /// <param name="compositeKey">Key of the composite (that contains settings).</param>
+    /// <param name="key">Key of the object.</param>
+    /// <param name="value">The value of the object retrieved.</param>
+    /// <returns>The T object.</returns>
+    public bool TryRead<T>(string compositeKey, string key, out T? value)
+    {
+        if (TryRead(compositeKey, out ApplicationDataCompositeValue? composite) && composite != null)
+        {
+            string compositeValue = (string)composite[key];
+            if (compositeValue != null)
+            {
+                value = Serializer.Deserialize<T>(compositeValue);
+                return true;
+            }
+        }
+
+        value = default;
+        return false;
+    }
+
+    /// <summary>
+    /// Retrieves a single item by its key in composite.
+    /// </summary>
+    /// <typeparam name="T">Type of object retrieved.</typeparam>
+    /// <param name="compositeKey">Key of the composite (that contains settings).</param>
+    /// <param name="key">Key of the object.</param>
+    /// <param name="default">Default value of the object.</param>
+    /// <returns>The T object.</returns>
+    public T? Read<T>(string compositeKey, string key, T? @default = default)
+    {
+        if (TryRead(compositeKey, out ApplicationDataCompositeValue? composite) && composite != null)
+        {
+            if (composite.TryGetValue(key, out var valueObj) && valueObj is string value)
+            {
+                return Serializer.Deserialize<T>(value);
+            }
+        }
+
+        return @default;
+    }
+
+    /// <summary>
+    /// Saves a group of items by its key in a composite.
+    /// This method should be considered for objects that do not exceed 8k bytes during the lifetime of the application
+    /// and for groups of settings which need to be treated in an atomic way.
+    /// </summary>
+    /// <typeparam name="T">Type of object saved.</typeparam>
+    /// <param name="compositeKey">Key of the composite (that contains settings).</param>
+    /// <param name="values">Objects to save.</param>
+    public void Save<T>(string compositeKey, IDictionary<string, T> values)
+    {
+        if (TryRead(compositeKey, out ApplicationDataCompositeValue? composite) && composite != null)
+        {
+            foreach (KeyValuePair<string, T> setting in values)
+            {
+                var serializedValue = Serializer.Serialize(setting.Value) ?? string.Empty;
+                if (composite.ContainsKey(setting.Key))
+                {
+                    composite[setting.Key] = serializedValue;
+                }
+                else
+                {
+                    composite.Add(setting.Key, serializedValue);
+                }
+            }
+        }
+        else
+        {
+            composite = [];
+            foreach (KeyValuePair<string, T> setting in values)
+            {
+                var serializedValue = Serializer.Serialize(setting.Value) ?? string.Empty;
+                composite.Add(setting.Key, serializedValue);
+            }
+
+            Settings.Values[compositeKey] = composite;
+        }
+    }
+
+    /// <summary>
+    /// Deletes a single item by its key in composite.
+    /// </summary>
+    /// <param name="compositeKey">Key of the composite (that contains settings).</param>
+    /// <param name="key">Key of the object.</param>
+    /// <returns>A boolean indicator of success.</returns>
+    public bool TryDelete(string compositeKey, string key)
+    {
+        if (TryRead(compositeKey, out ApplicationDataCompositeValue? composite) && composite != null)
+        {
+            return composite.Remove(key);
+        }
+
+        return false;
+    }
+
+    /// <inheritdoc />
+    public Task<IEnumerable<(DirectoryItemType ItemType, string Name)>> ReadFolderAsync(string folderPath)
+    {
+        return ReadFolderAsync(Folder, folderPath);
+    }
+
+
+    /// <inheritdoc />
+    public Task CreateFolderAsync(string folderPath)
+    {
+        return CreateFolderAsync(Folder, folderPath);
+    }
+
+    /// <inheritdoc />
+    public Task<bool> TryDeleteItemAsync(string itemPath)
+    {
+        return TryDeleteItemAsync(Folder, itemPath);
+    }
+
+    /// <inheritdoc />
+    public Task<bool> TryRenameItemAsync(string itemPath, string newName)
+    {
+        return TryRenameItemAsync(Folder, itemPath, newName);
+    }
+
+    private async Task<IEnumerable<(DirectoryItemType, string)>> ReadFolderAsync(StorageFolder folder, string folderPath)
+    {
+        var targetFolder = await folder.GetFolderAsync(NormalizePath(folderPath));
+        var items = await targetFolder.GetItemsAsync();
+
+        return items.Select((item) =>
+        {
+            var itemType = item.IsOfType(StorageItemTypes.File) ? DirectoryItemType.File
+                : item.IsOfType(StorageItemTypes.Folder) ? DirectoryItemType.Folder
+                : DirectoryItemType.None;
+
+            return (itemType, item.Name);
+        });
+    }
+
+    private async Task CreateFolderAsync(StorageFolder folder, string folderPath)
+    {
+        await folder.CreateFolderAsync(NormalizePath(folderPath), CreationCollisionOption.OpenIfExists);
+    }
+
+    private async Task<bool> TryDeleteItemAsync(StorageFolder folder, string itemPath)
+    {
+        try
+        {
+            var item = await folder.GetItemAsync(NormalizePath(itemPath));
+            await item.DeleteAsync();
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private async Task<bool> TryRenameItemAsync(StorageFolder folder, string itemPath, string newName)
+    {
+        try
+        {
+            var item = await folder.GetItemAsync(NormalizePath(itemPath));
+            await item.RenameAsync(newName, NameCollisionOption.FailIfExists);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private string NormalizePath(string path)
+    {
+        var directoryName = Path.GetDirectoryName(path) ?? string.Empty;
+        var fileName = Path.GetFileName(path);
+        return Path.Combine(directoryName, fileName);
+    }
+}