PR updates

Author: shweaver-MSFT

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/ApplicationDataStorageHelper.cs

@@ -164,9 +164,9 @@ public void Delete(string compositeKey, string key)
         }
 
         /// <inheritdoc />
-        public Task<bool> FileExistsAsync(string filePath)
+        public Task<bool> ItemExistsAsync(string itemName)
         {
-            return FileExistsAsync(DefaultFolder, filePath);
+            return ItemExistsAsync(DefaultFolder, itemName);
         }
 
         /// <inheritdoc />
@@ -176,7 +176,7 @@ public Task<T> ReadFileAsync<T>(string filePath, T @default = default)
         }
 
         /// <inheritdoc />
-        public Task<IList<string>> ReadFolderAsync(string folderPath)
+        public Task<IList<Tuple<DirectoryItemType, string>>> ReadFolderAsync(string folderPath)
         {
             return ReadFolderAsync(DefaultFolder, folderPath);
         }
@@ -199,9 +199,27 @@ public Task DeleteItemAsync(string itemPath)
             return DeleteItemAsync(DefaultFolder, itemPath);
         }
 
-        private Task<bool> FileExistsAsync(StorageFolder folder, string filePath)
+        /// <summary>
+        /// Determine the existance of a file at the specified path.
+        /// To check for folders, use <see cref="ItemExistsAsync(string)" />.
+        /// </summary>
+        /// <param name="fileName">The name of the file.</param>
+        /// <param name="isRecursive">Whether the file should be searched for recursively.</param>
+        /// <returns>A task with the result of the file query.</returns>
+        public Task<bool> FileExistsAsync(string fileName, bool isRecursive = false)
+        {
+            return FileExistsAsync(DefaultFolder, fileName, isRecursive);
+        }
+
+        private async Task<bool> ItemExistsAsync(StorageFolder folder, string itemName)
         {
-            return folder.FileExistsAsync(filePath);
+            var item = await folder.TryGetItemAsync(itemName);
+            return item != null;
+        }
+
+        private Task<bool> FileExistsAsync(StorageFolder folder, string fileName, bool isRecursive)
+        {
+            return folder.FileExistsAsync(fileName, isRecursive);
         }
 
         private async Task<T> ReadFileAsync<T>(StorageFolder folder, string filePath, T @default = default)
@@ -210,11 +228,19 @@ private async Task<T> ReadFileAsync<T>(StorageFolder folder, string filePath, T
             return (value != null) ? _serializer.Deserialize<T>(value) : @default;
         }
 
-        private async Task<IList<string>> ReadFolderAsync(StorageFolder folder, string folderPath)
+        private async Task<IList<Tuple<DirectoryItemType, string>>> ReadFolderAsync(StorageFolder folder, string folderPath)
         {
             var targetFolder = await folder.GetFolderAsync(folderPath);
-            var files = await targetFolder.GetFilesAsync();
-            return files.Select((f) => f.Path + f.Name).ToList();
+            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 new Tuple<DirectoryItemType, string>(itemType, item.Name);
+            }).ToList();
         }
 
         private Task SaveFileAsync<T>(StorageFolder folder, string filePath, T value)

Microsoft.Toolkit.Uwp/Helpers/ObjectStorage/LocalObjectStorageHelper.cs

@@ -10,7 +10,7 @@ namespace Microsoft.Toolkit.Uwp.Helpers
     /// <summary>
     /// Store data in the Local environment (only on the current device).
     /// </summary>
-    [Obsolete("LocalObjectStorageHelper is deprecated and has been superceded by the ApplicationDataStorageHelper.")]
+    [Obsolete("LocalObjectStorageHelper is deprecated and has been superceded by the ApplicationDataStorageHelper. To upgrade, simply swap any LocalObjectStorageHelper instances with ApplicationDataStorageHelper.GetCurrent(serializer). The underlying interfaces are nearly identical but now with even more features available, such as deletion and access to user specific data stores!")]
     public class LocalObjectStorageHelper : BaseObjectStorageHelper
     {
         /// <summary>

Microsoft.Toolkit/Helpers/ObjectStorage/DirectoryItemType.cs

@@ -0,0 +1,27 @@
+// 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.
+
+namespace Microsoft.Toolkit.Helpers
+{
+    /// <summary>
+    /// Represents the types of items available in a directory.
+    /// </summary>
+    public enum DirectoryItemType
+    {
+        /// <summary>
+        /// The item is neither a file or a folder.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Represents a file type item.
+        /// </summary>
+        File,
+
+        /// <summary>
+        /// Represents a folder type item.
+        /// </summary>
+        Folder
+    }
+}

Microsoft.Toolkit/Helpers/ObjectStorage/IFileStorageHelper.cs

@@ -2,22 +2,28 @@
 // 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.Threading.Tasks;
 
 namespace Microsoft.Toolkit.Helpers
 {
     /// <summary>
-    /// Service interface used to store data in files and folders.
+    /// Service interface used to store data in a directory/file-system via files and folders.
+    ///
+    /// This interface is meant to help abstract file storage operations across platforms in a library,
+    /// but the actual behavior will be up to the implementer. Such as, we don't provide a sense of a current directory,
+    /// so an implementor should consider using full paths to support any file operations. Otherwise, a "directory aware"
+    /// implementation could be achieved with a current directory field and traversal functions, in which case relative paths would be applicable.
     /// </summary>
     public interface IFileStorageHelper
     {
         /// <summary>
-        /// Determines whether a file already exists.
+        /// Determines if a directory item already exists.
         /// </summary>
-        /// <param name="filePath">Key of the file (that contains object).</param>
-        /// <returns>True if a value exists.</returns>
-        Task<bool> FileExistsAsync(string filePath);
+        /// <param name="itemName">Key of the file.</param>
+        /// <returns>True if an item exists.</returns>
+        Task<bool> ItemExistsAsync(string itemName);
 
         /// <summary>
         /// Retrieves an object from a file.
@@ -29,11 +35,11 @@ public interface IFileStorageHelper
         Task<T> ReadFileAsync<T>(string filePath, T? @default = default);
 
         /// <summary>
-        /// Retrieves all file listings for a folder.
+        /// Retrieves the listings for a folder and the item types.
         /// </summary>
         /// <param name="folderPath">The path to the target folder.</param>
-        /// <returns>A list of file names in the target folder.</returns>
-        Task<IList<string>> ReadFolderAsync(string folderPath);
+        /// <returns>A list of file types and names in the target folder.</returns>
+        Task<IList<Tuple<DirectoryItemType, string>>> ReadFolderAsync(string folderPath);
 
         /// <summary>
         /// Saves an object inside a file.
@@ -45,7 +51,7 @@ public interface IFileStorageHelper
         Task SaveFileAsync<T>(string filePath, T value);
 
         /// <summary>
-        /// Saves a folder.
+        /// Ensure a folder exists at the folder path specified.
         /// </summary>
         /// <param name="folderPath">The path and name of the target folder.</param>
         /// <returns>Waiting task until completion.</returns>