Add Storage.Devices to support ESP32 mount operations

source/Windows.Storage/FileIO.cs

@@ -158,7 +158,7 @@ public static void WriteBuffer(IStorageFile file, IBuffer buffer)
         [System.Diagnostics.DebuggerStepThrough]
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        public extern static void ReadTextNative(IStorageFile file, ref string text);
+        private extern static void ReadTextNative(IStorageFile file, ref string text);
         #endregion
 
     }

source/Windows.Storage/IStorageProvider.cs

@@ -7,6 +7,9 @@
 
 namespace Windows.Storage
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public interface IStorageProvider
     {
     }

source/Windows.Storage/KnownFolderId.cs

@@ -75,5 +75,11 @@ public enum KnownFolderId
         ///// Videos library folder.
         ///// </summary>
         //VideosLibrary = 13
+
+        /// <summary>
+        /// Internal devices.
+        /// </summary>
+        InternalDevices = 14
+
     }
 }

source/Windows.Storage/KnownFolders.cs

@@ -28,6 +28,13 @@ public static class KnownFolders
         /// </summary>
         public static StorageFolder RemovableDevices => new StorageFolder(KnownFolderId.RemovableDevices);
 
+
+        /// <summary>
+        /// Gets the internal devices folder.
+        /// </summary>
+        public static StorageFolder InternalDevices => new StorageFolder(KnownFolderId.InternalDevices);
+
+
         //public static StorageFolder SavedPictures { get; }
         //public static StorageFolder VideosLibrary { get; }
 

source/Windows.Storage/StorageDevices.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Runtime.CompilerServices;
+
+
+namespace Windows.Storage.Devices
+{
+    /// <summary>
+    /// Class to allow a single SDCard to be mounted on the system.
+    /// Only allows for 1 device to be mounted, either via MMC or SPI
+    /// </summary>
+    public static class SDCard
+    {
+
+#pragma warning disable 0649
+
+        // this field is set in native code
+        [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
+        private static bool _mounted = false;
+
+#pragma warning restore 0649
+
+        /// <summary>
+        /// Indcates if the SDscard has been mounted
+        /// </summary>
+        public static bool IsMounted => _mounted;
+
+        /// <summary>
+        /// Mount the SDcard device on the MMC interface 
+        /// </summary>
+        /// <param name="Data1bit">If true denotes 1 bit data path will be used otherwise it will be 4 bits.</param>
+        /// <remarks>
+        /// This will try to mount the SDCard on the specified interface.
+        /// If the Card is not present or the card is unable to be read then an exception will be thrown.
+        /// </remarks>
+        [System.Diagnostics.DebuggerStepThrough]
+        public static void MountMMC(bool Data1bit)
+        {
+            MountMMCNative(Data1bit);
+            _mounted = true;
+        }
+
+        /// <summary>
+        /// Mount the SPI SDcard device on the specified SPI bus 
+        /// </summary>
+        /// <param name="SpiController">The name for the SPI device, i.e "SPI1" </param>
+        /// <param name="ChipSelect">The GPIO pin used for chip select on SDcard.</param>
+        /// <remarks>
+        /// This will try to mount the SDCard on the specified interface.
+        /// If the Card is not present or the card is unable to be read then an exception will be thrown.
+        /// </remarks>
+        [System.Diagnostics.DebuggerStepThrough]
+        public static void MountSpi(string SpiController, int ChipSelect)
+        {
+            // the SpiDevice is an ASCII string with the format 'SPIn'
+            // need to grab 'n' from the string and convert that to the integer value from the ASCII code (do this by subtracting 48 from the char value)
+            int spiBus = SpiController[3] - '0';
+            MountSpiNative(spiBus, ChipSelect);
+
+            // If no exception then set mounted flag
+            _mounted = true;
+        }
+
+        /// <summary>
+        /// Unmount the mounted SDcard.
+        /// </summary>
+        [System.Diagnostics.DebuggerStepThrough]
+        public static void Unmount()
+        {
+            UnmountNative();
+
+            // If no exception then set mounted flag
+            _mounted = false;
+        }
+
+#region Native Calls
+
+        [System.Diagnostics.DebuggerStepThrough]
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private extern static void MountMMCNative(bool Data1bit);
+
+        [System.Diagnostics.DebuggerStepThrough]
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void MountSpiNative(int SpiBus, int ChipSelect);
+
+        [System.Diagnostics.DebuggerStepThrough]
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void UnmountNative();
+
+#endregion
+
+    }
+}
+

source/Windows.Storage/StorageFile.cs

@@ -3,8 +3,8 @@
 // See LICENSE file in the project root for full license information.
 //
 
-
 using System;
+using System.Runtime.CompilerServices;
 
 namespace Windows.Storage
 {
@@ -160,6 +160,27 @@ public string FileType
         //        public static IAsyncOperation<StorageFile> GetFileFromPathAsync(String path)
         //        { }
 
+        /// <summary>
+        /// Gets a StorageFile object to represent the file at the specified path.
+        /// </summary>
+        /// <param name="path">The path of the file to get a StorageFile to represent.</param>
+        /// <returns>Returns the file as a StorageFile.</returns>
+        ///<remarks>
+        ///
+        /// This method is exclusive of nanoFramework and it's not available in the UWP API.
+        /// The equivalent method would be GetFileFromPathAsync(String).
+        ///</remarks>
+        public static StorageFile GetFileFromPath(String path)
+        {
+            StorageFile file = new StorageFile();
+
+            CheckFileNative(path);
+
+            file._path = path;
+
+            return file;
+        }
+
         //        public IAsyncOperation<StorageFolder> GetParentAsync()
         //        { }
 
@@ -202,6 +223,7 @@ public string FileType
         //        public IAsyncOperation<IRandomAccessStream> OpenAsync(FileAccessMode accessMode)
         //        { }
 
+
         //        public IAsyncOperation<IRandomAccessStream> OpenAsync(FileAccessMode accessMode, StorageOpenOptions options)
         //        { }
 
@@ -228,5 +250,12 @@ public string FileType
 
         //        public static IAsyncOperation<StorageFile> ReplaceWithStreamedFileFromUriAsync(IStorageFile fileToReplace, Uri uri, IRandomAccessStreamReference thumbnail)
         //        { }
+
+
+        [System.Diagnostics.DebuggerStepThrough]
+        [System.Diagnostics.DebuggerHidden]
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void CheckFileNative(string filePath);
+
     }
 }

source/Windows.Storage/StorageFolder.cs

@@ -18,6 +18,7 @@ public sealed class StorageFolder : IStorageFolder//, IStorageFolder2, IStorageI
 
         private const string s_RemovableStorageDevicesName = "Removable Storage Devices";
         private const string s_RemovableStorageDevicesDisplayType = "System Folder";
+        private const string s_InternalStorageDevicesName = "Internal Storage Devices";
 
         #endregion
 
@@ -105,14 +106,22 @@ public sealed class StorageFolder : IStorageFolder//, IStorageFolder2, IStorageI
 
         internal StorageFolder(KnownFolderId folderId)
         {
-            // currently there is only support for removable devices
-            if (folderId != KnownFolderId.RemovableDevices)
+            // currently there is only support for removable devices 
+            // and internal storage devices
+            if (folderId == KnownFolderId.RemovableDevices)
+            {
+                _name = s_RemovableStorageDevicesName;
+            }
+            else if (folderId == KnownFolderId.InternalDevices)
+            {
+                _name = s_InternalStorageDevicesName;
+            }
+            else
             {
                 throw new NotSupportedException();
             }
 
             _knownFolderId = folderId;
-            _name = s_RemovableStorageDevicesName;
             _path = "";
         }
 
@@ -310,13 +319,17 @@ public StorageFile[] GetFiles(CommonFileQuery query, UInt32 startIndex, UInt32 m
         public StorageFolder[] GetFolders()
         {
             // is this a call for a known folder ID
-            // RemovableDevices
+            // RemovableDevices & InternalDevices
             // nothing else is implemented, no need to check as this doesn't get pass the constructor StorageFolder(KnownFolderId folderId)
             if (_knownFolderId == KnownFolderId.RemovableDevices)
             {
                 return GetRemovableStorageFoldersNative();
             }
-
+            else if (_knownFolderId == KnownFolderId.InternalDevices)
+            {
+                return GetInternalStorageFoldersNative();
+            }
+
             // regular get folders
             return GetStorageFoldersNative();
         }
@@ -401,6 +414,11 @@ public bool IsCommonFileQuerySupported(CommonFileQuery query)
         [MethodImpl(MethodImplOptions.InternalCall)]
         private extern StorageFolder[] GetRemovableStorageFoldersNative();
 
+        [System.Diagnostics.DebuggerStepThrough]
+        [System.Diagnostics.DebuggerHidden]
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private extern StorageFolder[] GetInternalStorageFoldersNative();
+
         [System.Diagnostics.DebuggerStepThrough]
         [System.Diagnostics.DebuggerHidden]
         [MethodImpl(MethodImplOptions.InternalCall)]

source/Windows.Storage/Windows.Storage.nfproj

@@ -94,6 +94,7 @@
     <Compile Include="SetVersionDeferral.cs" />
     <Compile Include="SetVersionRequest.cs" />
     <Compile Include="StorageDeleteOption.cs" />
+    <Compile Include="StorageDevices.cs" />
     <Compile Include="StorageEventManager.cs" />
     <Compile Include="RemovableDeviceEventArgs.cs" />
     <Compile Include="StorageFile.cs" />