Feature: Added file tags widget

src/Files.App.Storage/FtpStorage/FtpStorable.cs

@@ -1,4 +1,5 @@
 using Files.Sdk.Storage.LocatableStorage;
+using Files.Shared.Helpers;
 using FluentFTP;
 using System.Threading;
 using System.Threading.Tasks;
@@ -7,22 +8,24 @@ namespace Files.App.Storage.FtpStorage
 {
 	public abstract class FtpStorable : ILocatableStorable
 	{
+		private string? _computedId;
+
 		/// <inheritdoc/>
 		public string Path { get; protected set; }
 
 		/// <inheritdoc/>
 		public string Name { get; protected set; }
 
 		/// <inheritdoc/>
-		public string Id { get; protected set; }
+		public virtual string Id => _computedId ??= ChecksumHelpers.CalculateChecksumForPath(Path);
 
 		protected internal FtpStorable(string path, string name)
 		{
 			Path = FtpHelpers.GetFtpPath(path);
 			Name = name;
-			Id = string.Empty;
 		}
 
+		/// <inheritdoc/>
 		public virtual Task<ILocatableFolder?> GetParentAsync(CancellationToken cancellationToken = default)
 		{
 			return Task.FromResult<ILocatableFolder?>(null);

src/Files.App.Storage/FtpStorage/FtpStorageFile.cs

@@ -15,7 +15,7 @@ public FtpStorageFile(string path, string name)
 		}
 
 		/// <inheritdoc/>
-		public async Task<Stream> OpenStreamAsync(FileAccess access, FileShare share, CancellationToken cancellationToken = default)
+		public async Task<Stream> OpenStreamAsync(FileAccess access, CancellationToken cancellationToken = default)
 		{
 			using var ftpClient = GetFtpClient();
 			await ftpClient.EnsureConnectedAsync(cancellationToken);
@@ -30,7 +30,7 @@ public async Task<Stream> OpenStreamAsync(FileAccess access, FileShare share, Ca
 			}
 			else
 			{
-				throw new ArgumentException($"Invalid {nameof(share)} flag.");
+				throw new ArgumentException($"Invalid {nameof(access)} flag.");
 			}
 		}
 	}

src/Files.App.Storage/FtpStorage/FtpFileSystemService.cs → src/Files.App.Storage/FtpStorage/FtpStorageService.cs

@@ -1,5 +1,5 @@
+using Files.Sdk.Storage;
 using Files.Sdk.Storage.LocatableStorage;
-using Files.Sdk.Storage.Services;
 using FluentFTP;
 using System;
 using System.IO;
@@ -8,9 +8,9 @@
 
 namespace Files.App.Storage.FtpStorage
 {
-	public sealed class FtpFileSystemService : IFileSystemService
+	public sealed class FtpStorageService : IStorageService
 	{
-		public Task<bool> IsFileSystemAccessibleAsync(CancellationToken cancellationToken = default)
+		public Task<bool> IsAccessibleAsync(CancellationToken cancellationToken = default)
 		{
 			return Task.FromResult(true); // TODO: Check if FTP is available
 		}

src/Files.App.Storage/NativeStorage/NativeFile.cs

@@ -0,0 +1,32 @@
+using Files.Sdk.Storage;
+using Files.Sdk.Storage.ExtendableStorage;
+using Files.Sdk.Storage.LocatableStorage;
+using Files.Sdk.Storage.ModifiableStorage;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Files.App.Storage.NativeStorage
+{
+	/// <inheritdoc cref="IFile"/>
+    public sealed class NativeFile : NativeStorable, ILocatableFile, IModifiableFile, IFileExtended
+	{
+		public NativeFile(string path)
+			: base(path)
+		{
+		}
+
+		/// <inheritdoc/>
+		public Task<Stream> OpenStreamAsync(FileAccess access, CancellationToken cancellationToken = default)
+		{
+			return OpenStreamAsync(access, FileShare.None, cancellationToken);
+		}
+
+		/// <inheritdoc/>
+		public Task<Stream> OpenStreamAsync(FileAccess access, FileShare share = FileShare.None, CancellationToken cancellationToken = default)
+		{
+			var stream = File.Open(Path, FileMode.Open, access, share);
+			return Task.FromResult<Stream>(stream);
+		}
+	}
+}

src/Files.App.Storage/NativeStorage/NativeFolder.cs

@@ -0,0 +1,202 @@
+using Files.Sdk.Storage;
+using Files.Sdk.Storage.Enums;
+using Files.Sdk.Storage.Extensions;
+using Files.Sdk.Storage.LocatableStorage;
+using Files.Sdk.Storage.ModifiableStorage;
+using Files.Sdk.Storage.MutableStorage;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Files.App.Storage.NativeStorage
+{
+    /// <inheritdoc cref="IFolder"/>
+    public sealed class NativeFolder : NativeStorable, ILocatableFolder, IModifiableFolder, IMutableFolder
+    {
+        public NativeFolder(string path)
+            : base(path)
+        {
+        }
+
+        /// <inheritdoc/>
+        public Task<IFile> GetFileAsync(string fileName, CancellationToken cancellationToken = default)
+        {
+            var path = System.IO.Path.Combine(Path, fileName);
+
+            if (!File.Exists(path))
+                throw new FileNotFoundException();
+
+            return Task.FromResult<IFile>(new NativeFile(path));
+        }
+
+        /// <inheritdoc/>
+        public Task<IFolder> GetFolderAsync(string folderName, CancellationToken cancellationToken = default)
+        {
+            var path = System.IO.Path.Combine(Path, folderName);
+
+            if (!Directory.Exists(path))
+                throw new FileNotFoundException();
+
+            return Task.FromResult<IFolder>(new NativeFolder(path));
+        }
+
+        /// <inheritdoc/>
+        public async IAsyncEnumerable<IStorable> GetItemsAsync(StorableKind kind = StorableKind.All, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+        {
+            if (kind == StorableKind.Files)
+            {
+                foreach (var item in Directory.EnumerateFiles(Path))
+                    yield return new NativeFile(item);
+            }
+            else if (kind == StorableKind.Folders)
+            {
+                foreach (var item in Directory.EnumerateDirectories(Path))
+                    yield return new NativeFolder(item);
+            }
+            else
+            {
+                foreach (var item in Directory.EnumerateFileSystemEntries(Path))
+                {
+                    if (File.Exists(item))
+                        yield return new NativeFile(item);
+                    else
+                        yield return new NativeFolder(item);
+                }
+            }
+
+            await Task.CompletedTask;
+        }
+
+        /// <inheritdoc/>
+        public Task DeleteAsync(IStorable item, bool permanently = false, CancellationToken cancellationToken = default)
+        {
+            _ = permanently;
+
+            if (item is ILocatableFile locatableFile)
+            {
+                File.Delete(locatableFile.Path);
+            }
+            else if (item is ILocatableFolder locatableFolder)
+            {
+                Directory.Delete(locatableFolder.Path, true);
+            }
+            else
+                throw new ArgumentException($"Could not delete {item}.");
+
+            return Task.CompletedTask;
+        }
+
+        /// <inheritdoc/>
+        public async Task<IStorable> CreateCopyOfAsync(IStorable itemToCopy, CreationCollisionOption collisionOption = default, CancellationToken cancellationToken = default)
+        {
+            var overwrite = collisionOption == CreationCollisionOption.ReplaceExisting;
+
+            if (itemToCopy is IFile sourceFile)
+            {
+                if (itemToCopy is ILocatableFile sourceLocatableFile)
+                {
+                    var newPath = System.IO.Path.Combine(Path, itemToCopy.Name);
+                    File.Copy(sourceLocatableFile.Path, newPath, overwrite);
+
+                    return new NativeFile(newPath);
+                }
+
+                var copiedFile = await CreateFileAsync(itemToCopy.Name, collisionOption, cancellationToken);
+                await sourceFile.CopyContentsToAsync(copiedFile, cancellationToken);
+
+                return copiedFile;
+            }
+            else if (itemToCopy is IFolder sourceFolder)
+            {
+                // TODO: Implement folder copy
+                throw new NotSupportedException();
+            }
+
+            throw new ArgumentException($"Could not copy type {itemToCopy.GetType()}");
+        }
+
+        /// <inheritdoc/>
+        public async Task<IStorable> MoveFromAsync(IStorable itemToMove, IModifiableFolder source, CreationCollisionOption collisionOption = default, CancellationToken cancellationToken = default)
+        {
+            var overwrite = collisionOption == CreationCollisionOption.ReplaceExisting;
+
+            if (itemToMove is IFile sourceFile)
+            {
+	            if (itemToMove is ILocatableFile sourceLocatableFile)
+	            {
+		            var newPath = System.IO.Path.Combine(Path, itemToMove.Name);
+		            File.Move(sourceLocatableFile.Path, newPath, overwrite);
+
+		            return new NativeFile(newPath);
+	            }
+
+	            var copiedFile = await CreateFileAsync(itemToMove.Name, collisionOption, cancellationToken);
+	            await sourceFile.CopyContentsToAsync(copiedFile, cancellationToken);
+	            await source.DeleteAsync(itemToMove, true, cancellationToken);
+
+	            return copiedFile;
+            }
+            else if (itemToMove is IFolder sourceFolder)
+            {
+                throw new NotImplementedException();
+            }
+
+            throw new ArgumentException($"Could not move type {itemToMove.GetType()}");
+        }
+
+        /// <inheritdoc/>
+        public async Task<IFile> CreateFileAsync(string desiredName, CreationCollisionOption collisionOption = default, CancellationToken cancellationToken = default)
+        {
+            var path = System.IO.Path.Combine(Path, desiredName);
+            if (File.Exists(path))
+            {
+                switch (collisionOption)
+                {
+                    case CreationCollisionOption.GenerateUniqueName:
+                        return await CreateFileAsync($"{System.IO.Path.GetFileNameWithoutExtension(desiredName)} (1){System.IO.Path.GetExtension(desiredName)}", collisionOption, cancellationToken);
+
+                    case CreationCollisionOption.OpenIfExists:
+                        return new NativeFile(path);
+
+                    case CreationCollisionOption.FailIfExists:
+                        throw new IOException("File already exists with the same name.");
+                }
+            }
+
+            await File.Create(path).DisposeAsync();
+            return new NativeFile(path);
+        }
+
+        /// <inheritdoc/>
+        public Task<IFolder> CreateFolderAsync(string desiredName, CreationCollisionOption collisionOption = default, CancellationToken cancellationToken = default)
+        {
+            var path = System.IO.Path.Combine(Path, desiredName);
+            if (Directory.Exists(path))
+            {
+                switch (collisionOption)
+                {
+                    case CreationCollisionOption.GenerateUniqueName:
+                        return CreateFolderAsync($"{desiredName} (1)", collisionOption, cancellationToken);
+
+                    case CreationCollisionOption.OpenIfExists:
+                        return Task.FromResult<IFolder>(new NativeFolder(path));
+
+                    case CreationCollisionOption.FailIfExists:
+                        throw new IOException("Folder already exists with the same name.");
+                }
+            }
+
+            _ = Directory.CreateDirectory(path);
+            return Task.FromResult<IFolder>(new NativeFolder(path));
+        }
+
+        /// <inheritdoc/>
+        public Task<IFolderWatcher> GetFolderWatcherAsync(CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult<IFolderWatcher>(new NativeFolderWatcher(this));
+        }
+    }
+}

src/Files.App.Storage/NativeStorage/NativeFolderWatcher.cs

@@ -0,0 +1,88 @@
+using Files.Sdk.Storage.LocatableStorage;
+using Files.Sdk.Storage.MutableStorage;
+using System.Collections.Specialized;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Files.App.Storage.NativeStorage
+{
+	/// <inheritdoc cref="IFolderWatcher"/>
+    public sealed class NativeFolderWatcher : IFolderWatcher
+	{
+		private FileSystemWatcher? _fileSystemWatcher;
+		private NotifyCollectionChangedEventHandler? _collectionChanged;
+
+		public IMutableFolder Folder { get; }
+
+		/// <inheritdoc/>
+		public event NotifyCollectionChangedEventHandler? CollectionChanged
+		{
+			add
+			{
+				if (_fileSystemWatcher is not null)
+					_fileSystemWatcher.EnableRaisingEvents = true;
+
+				_collectionChanged += value;
+			}
+			remove
+			{
+				if (_fileSystemWatcher is not null)
+					_fileSystemWatcher.EnableRaisingEvents = false;
+
+				_collectionChanged -= value;
+			}
+		}
+
+		public NativeFolderWatcher(IMutableFolder folder)
+		{
+			Folder = folder;
+			SetupWatcher();
+		}
+
+		private void SetupWatcher()
+		{
+			if (Folder is ILocatableFolder locatableFolder)
+			{
+				_fileSystemWatcher = new(locatableFolder.Path);
+				_fileSystemWatcher.Created += FileSystemWatcher_Created;
+				_fileSystemWatcher.Deleted += FileSystemWatcher_Deleted;
+				_fileSystemWatcher.Renamed += FileSystemWatcher_Renamed;
+			}
+		}
+
+		private void FileSystemWatcher_Renamed(object sender, RenamedEventArgs e)
+		{
+			_collectionChanged?.Invoke(this, new(NotifyCollectionChangedAction.Replace, e.FullPath, e.OldFullPath));
+		}
+
+		private void FileSystemWatcher_Deleted(object sender, FileSystemEventArgs e)
+		{
+			_collectionChanged?.Invoke(this, new(NotifyCollectionChangedAction.Remove, e.FullPath));
+		}
+
+		private void FileSystemWatcher_Created(object sender, FileSystemEventArgs e)
+		{
+			_collectionChanged?.Invoke(this, new(NotifyCollectionChangedAction.Add, e.FullPath));
+		}
+
+		/// <inheritdoc/>
+		public ValueTask DisposeAsync()
+		{
+			Dispose();
+			return default;
+		}
+
+		/// <inheritdoc/>
+		public void Dispose()
+		{
+			if (_fileSystemWatcher is not null)
+			{
+				_fileSystemWatcher.EnableRaisingEvents = false;
+				_fileSystemWatcher.Created -= FileSystemWatcher_Created;
+				_fileSystemWatcher.Deleted -= FileSystemWatcher_Deleted;
+				_fileSystemWatcher.Renamed -= FileSystemWatcher_Renamed;
+				_fileSystemWatcher.Dispose();
+			}
+		}
+	}
+}