Finden Sie die Speicher Karte ein Pfad auf WM6

Im Hinterkopf behalten: "\Storage Card" ist Englisch orientiert. Ein Gerät für eine andere region kann einen anderen Namen haben. Der name der Speicherkarte Weg auf mein Gerät variiert, wie ich bin mit dem Gerät.

Einiger Zeit in der MSDN-Formen, die ich beantwortet ein paar Fragen, wie zu erkennen die Lagerung von Karten im file-system und wie bekommt man die Speicher-Karte die Kapazität. Ich schrieb den folgenden, könnte eine Antwort auf diese Fragen und dachte, es wäre hilfreich, zu teilen. Speicher-Karten zeigen, bis in das Datei-system als temporäre Verzeichnisse. Dieses Programm untersucht die Objekte, die in der Wurzel des Geräts und alle Ordner, die temp-Attribut berücksichtigt werden, um eine positive übereinstimmung

using System;
using System.IO;
using System.Runtime.InteropServices;

namespace StorageCardInfo
{
    class Program
    {
        const ulong Megabyte = 1048576;
        const ulong Gigabyte = 1073741824;

        [DllImport("CoreDLL")]
        static extern int GetDiskFreeSpaceEx(
        string DirectoryName,
        out ulong lpFreeBytesAvailableToCaller,
        out ulong lpTotalNumberOfBytes,
        out ulong lpTotalNumberOfFreeBytes 
    );

    static void Main(string[] args)
    {
        DirectoryInfo root = new DirectoryInfo("\\");
        DirectoryInfo[] directoryList = root.GetDirectories();
        ulong FreeBytesAvailable;
        ulong TotalCapacity;
        ulong TotalFreeBytes;

        for (int i = 0; i < directoryList.Length; ++i)
        {
            if ((directoryList.Attributes & FileAttributes.Temporary) != 0)
            {
                GetDiskFreeSpaceEx(directoryList.FullName, out FreeBytesAvailable, out TotalCapacity, out TotalFreeBytes);
                Console.Out.WriteLine("Storage card name: {0}", directoryList.FullName);
                Console.Out.WriteLine("Available Bytes : {0}", FreeBytesAvailable);
                Console.Out.WriteLine("Total Capacity : {0}", TotalCapacity);
                Console.Out.WriteLine("Total Free Bytes : {0}", TotalFreeBytes);
            }
        }
    }
}

Habe ich gefunden mit der FindFirstFlashCard/FindNextFlashCard APIs zuverlässiger als das auflisten der Verzeichnisse und die überprüfung der temporären Flagge (zurück-bluetooth-shared-Ordner zum Beispiel).

Die folgende Beispielanwendung zeigt, wie Sie zu nutzen und die erforderlichen P/Invoke Aussagen.

using System;
using System.Runtime.InteropServices;

namespace RemovableStorageTest
{
    class Program
    {
        static void Main(string[] args)
        {
            string removableDirectory = GetRemovableStorageDirectory();
            if (removableDirectory != null)
            {
                Console.WriteLine(removableDirectory);
            }
            else
            {
                Console.WriteLine("No removable drive found");
            }
        }

        public static string GetRemovableStorageDirectory()
        {
            string removableStorageDirectory = null;

            WIN32_FIND_DATA findData = new WIN32_FIND_DATA();
            IntPtr handle = IntPtr.Zero;

            handle = FindFirstFlashCard(ref findData);

            if (handle != INVALID_HANDLE_VALUE)
            {
                do
                {
                    if (!string.IsNullOrEmpty(findData.cFileName))
                    {
                        removableStorageDirectory = findData.cFileName;
                        break;
                    }
                }
                while (FindNextFlashCard(handle, ref findData));
                FindClose(handle);
            }

            return removableStorageDirectory;
        }

        public static readonly IntPtr INVALID_HANDLE_VALUE = (IntPtr)(-1);

        //The CharSet must match the CharSet of the corresponding PInvoke signature
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        public struct WIN32_FIND_DATA
        {
            public int dwFileAttributes;
            public FILETIME ftCreationTime;
            public FILETIME ftLastAccessTime;
            public FILETIME ftLastWriteTime;
            public int nFileSizeHigh;
            public int nFileSizeLow;
            public int dwOID;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
            public string cFileName;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
            public string cAlternateFileName;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct FILETIME
        {
            public int dwLowDateTime;
            public int dwHighDateTime;
        };

        [DllImport("note_prj", EntryPoint = "FindFirstFlashCard")]
        public extern static IntPtr FindFirstFlashCard(ref WIN32_FIND_DATA findData);

        [DllImport("note_prj", EntryPoint = "FindNextFlashCard")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public extern static bool FindNextFlashCard(IntPtr hFlashCard, ref WIN32_FIND_DATA findData);

        [DllImport("coredll")]
        public static extern bool FindClose(IntPtr hFindFile);
    }
}

Kann nicht fügen Sie einen Kommentar auf der TreeUK und ctacke Diskussionen unten :

Dies ist nicht garantiert zu finden
Speicher Karte - viele Geräte montieren
built-in-flash in der gleichen Weise, und es
würde zeigen, bis in dieser Liste als gut. –
ctacke 8. Mai um 18:23

Dies hat
gut für mich gearbeitet auf HTC und Psion
- Geräte. Welche Geräte sind Ihnen bekannt
dies funktioniert nicht auf? Wert wäre
sehen, wenn es gibt ein weiteres Attribut
Sie können Rabatt die build-in flash
Speicher mit. – TreeUK 9. Mai um 22:29

Zu geben, eine Idee, die auf einem Motorola MC75 (früher SymboL), habe ich dieses Stück (von native) code :

    WIN32_FIND_DATA cardinfo;
HANDLE  card = FindFirstFlashCard(&cardinfo);
if (card != INVALID_HANDLE_VALUE)
{
    TCHAR existFile[MAX_PATH];

    wprintf(_T("found : %s\n"), cardinfo.cFileName);

    while(FindNextFlashCard(card, &cardinfo))
    {
        wprintf(_T("found : %s\n"), cardinfo.cFileName);
    }
}
FindClose(card);

Debug-Ausgabe :

cardinfo.dwFileAttributes   0x00000110  unsigned long int
cardinfo.cFileName          "Application"   wchar_t[260]

cardinfo.dwFileAttributes   0x00000110  unsigned long int
cardinfo.cFileName          "Cache Disk"    wchar_t[260]

cardinfo.dwFileAttributes   0x00000110  unsigned long int
cardinfo.cFileName          "Storage Card"  wchar_t[260]

Die "Anwendung" und "disk-Cache" sind interne Flash-Laufwerke. Die "Speicherkarte" eine SD-Karte. Alle sind gekennzeichnet als ein Stick (die Sie sind), sondern nur "Storage Card" ist abnehmbar.

Poste ich hier den code, den ich verwenden, um die mount-Verzeichnisse der Speicher-Karten.
Der Teil, wo bekomme ich die flash-Karten-Pfade übernommen werden, Unglaublich die post mit ein paar änderungen.

Ist der größte Unterschied, dass ich durch die mount-Verzeichnisse von allen flash-Karten und ich halten das man(N), die mit dem Standard-Speicher-name der Karte, die ich gelesen habe von der Registrierung von windows.

Er löst das problem, dass man auf motorola smart-Geräte, bei denen es mehrere flash-Karten und nur einen sd-card-reader, dessen mount-dir Sie können den Namen ändern, von der Standardeinstellung, die durch das numerische suffix (ie. im englischen WM-Systeme: 'Storage Card' , 'Storage-Karte2" und so weiter).
Getestet habe ich es auf einigen motorola-Modellen (MC75, MC75A, MC90, MC65) mit WM 6.5 Deutsch.

Diese Lösung sollte funktionieren gut mit verschiedenen windows mobile Sprachen, aber ich weiß nicht, ob es umgehen können mit denen, die Veränderung der
Standard-name des Speicher-Karten.
Es hängt alles davon ab, ob das Gerät an den Hersteller aktualisiert die windows-Registrierung mit der neue Standard-Namen.

Wäre es toll, wenn Sie es testen auf verschiedenen WMs oder Geräten.
Feedback ist willkommen.

   //
   //the storage card is a flash drive mounted as a directory in the root folder 
   //of the smart device
   //
   //on english windows mobile systems the storage card is mounted in the directory "/Storage Card", 
   //if that directory already exists then it's mounted in "/Storage Card2" and so on
   //
   //the regional name of the mount base dir of the storage card can be found in
   //the registry at [HKEY_LOCAL_MACHINE\System\StorageManager\Profiles\SDMemory\Folder]
   // 
   //in order to find the path of the storage card we look for the flash drive that starts 
   //with the base name
   //

   public class StorageCard
   {
      private StorageCard()
      {
      }

      public static List<string> GetMountDirs()
      {
         string key = @"HKEY_LOCAL_MACHINE\System\StorageManager\Profiles\SDMemory";
         string storageCardBaseName = Registry.GetValue(key, "Folder", "Storage Card") as String;
         List<string> storageCards = new List<string>();
         foreach (string flashCard in GetFlashCardMountDirs())
         {
            string path = flashCard.Trim();
            if (path.StartsWith(storageCardBaseName))
            {
               storageCards.Add(path);
            }
         }
         return storageCards;
      }

      private static List<string> GetFlashCardMountDirs()
      {
         List<string> storages = new List<string>();

         WIN32_FIND_DATA findData = new WIN32_FIND_DATA();
         IntPtr handle = IntPtr.Zero;

         handle = FindFirstFlashCard(ref findData);

         if (handle != INVALID_HANDLE_VALUE)
         {
            do
            {
               if (!string.IsNullOrEmpty(findData.cFileName))
               {
                  storages.Add(findData.cFileName);
                  storages.Add(findData.cAlternateFileName);
               }
            }
            while (FindNextFlashCard(handle, ref findData));
            FindClose(handle);
         }

         return storages;
      }

      private static readonly IntPtr INVALID_HANDLE_VALUE = (IntPtr)(-1);    

      [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
      private struct WIN32_FIND_DATA
      {
         public int dwFileAttributes;
         public FILETIME ftCreationTime;
         public FILETIME ftLastAccessTime;
         public FILETIME ftLastWriteTime;
         public int nFileSizeHigh;
         public int nFileSizeLow;
         public int dwOID;
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
         public string cFileName;
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
         public string cAlternateFileName;
      }

      [StructLayout(LayoutKind.Sequential)]
      private struct FILETIME
      {
         public int dwLowDateTime;
         public int dwHighDateTime;
      };

      [DllImport("note_prj", EntryPoint = "FindFirstFlashCard")]
      private extern static IntPtr FindFirstFlashCard(ref WIN32_FIND_DATA findData);

      [DllImport("note_prj", EntryPoint = "FindNextFlashCard")]
      [return: MarshalAs(UnmanagedType.Bool)]
      private extern static bool FindNextFlashCard(IntPtr hFlashCard, ref WIN32_FIND_DATA findData);

      [DllImport("coredll")]
      private static extern bool FindClose(IntPtr hFindFile);
   }