Automatisches Starten mit automatischer Wiedergabe

Sie können AutoPlay verwenden, um Ihre App als Option bereitzustellen, wenn ein Benutzer ein Gerät an seinen PC anschließt. Hierzu zählen andere Geräte als Volumegeräte, wie Kameras oder Medienplayer, oder Volumegeräte wie USB-Sticks, SD-Karten oder DVDs. Sie können auch AutoPlay verwenden, um Ihre App als Option anzubieten, wenn Benutzer Dateien zwischen zwei PCs durch Annäherung (Antippen) austauschen.

Für AutoPlay-Inhalte registrieren

Sie können Anwendungen als Optionen für AutoPlay-Inhaltsereignisse registrieren. AutoPlay-Inhaltsereignisse werden ausgelöst, wenn ein Datenträger wie eine Kamera-Speicherkarte, ein USB-Stick oder eine DVD in den PC eingelegt wird. Hier zeigen wir Ihnen, wie Sie Ihre App als AutoPlay-Option identifizieren können, wenn ein Volumengerät von einer Kamera eingelegt wird.

In diesem Lernprogramm haben Sie eine Anwendung erstellt, die Bilddateien anzeigt oder sie in Pictures kopiert. Sie haben die App für das Inhaltsereignis AutoPlay ShowPicturesOnArrival registriert.

AutoPlay löst auch Inhaltsereignisse für Inhalte aus, die zwischen PCs durch Annäherung (Antippen) freigegeben werden. Sie können die Schritte und den Code in diesem Abschnitt verwenden, um Dateien zu handhaben, die zwischen PCs, die Proximity verwenden, freigegeben sind. In der folgenden Tabelle sind die AutoPlay-Inhaltsereignisse aufgeführt, die für die Freigabe von Inhalten durch die Verwendung von Proximity verfügbar sind.

Wenn Dateien mithilfe von Proximity freigegeben werden, enthält die Eigenschaft Files des Objekts FileActivatedEventArgs einen Verweis auf einen Stammordner, der alle freigegebenen Dateien enthält.

Schritt 1: Erstellen Sie ein neues Projekt und fügen Sie AutoPlay-Deklarationen hinzu

1. Öffnen Sie Microsoft Visual Studio und wählen Sie Neues Projekt aus dem Menü Datei. Wählen Sie im Abschnitt Visual C# unter Windows die Option Blank App (Universal Windows). Nennen Sie die Anwendung AutoPlayDisplayOrCopyImages und klicken Sie auf OK.
2. Öffnen Sie die Datei Package.appxmanifest und wählen Sie die Registerkarte Capabilities. Wählen Sie die Funktionen Wechselmedien und Bilderbibliothek. Dadurch erhält die App Zugriff auf Wechseldatenträger für den Kameraspeicher und auf lokale Bilder.
3. Wählen Sie in der Manifestdatei die Registerkarte Declarations. Wählen Sie in der Dropdown-Liste Verfügbare Erklärungen die Option AutoPlay Content und klicken Sie auf Add. Wählen Sie das neue Element AutoPlay Content, das der Liste Supported Declarations hinzugefügt wurde.
4. Eine AutoPlay Content-Deklaration identifiziert Ihre App als eine Option, wenn AutoPlay ein Content-Ereignis auslöst. Das Ereignis basiert auf dem Inhalt eines Datenträgers wie z. B. einer DVD oder eines USB-Sticks. AutoPlay prüft den Inhalt des Volume-Geräts und bestimmt, welches Inhaltsereignis ausgelöst werden soll. Wenn das Stammverzeichnis des Volumes einen DCIM-, AVCHD- oder PRIVATE\ACHD-Ordner enthält oder wenn ein Benutzer Auswählen, was mit jedem Medientyp geschehen soll in der Systemsteuerung der automatischen Wiedergabe aktiviert hat und Bilder im Stammverzeichnis des Volumes gefunden werden, löst die automatische Wiedergabe das Ereignis ShowPicturesOnArrival aus. Geben Sie im Abschnitt Launch Actions die Werte aus Tabelle 1 unten für die erste Startaktion ein.
5. Klicken Sie im Abschnitt Launch Actions für das Element AutoPlay Content auf Add New, um eine zweite Startaktion hinzuzufügen. Geben Sie die Werte in Tabelle 2 unten für die zweite Startaktion ein.
6. Wählen Sie in der Dropdown-Liste Available Declarations die Option File Type Associations und klicken Sie auf Add. Setzen Sie in den Eigenschaften der neuen Deklaration File Type Associations das Feld Display Name auf AutoPlay Copy or Show Images und das Feld Name auf image_association1. Klicken Sie im Abschnitt Unterstützte Dateitypen auf Neu hinzufügen. Setzen Sie das Feld Dateityp auf .jpg. Setzen Sie im Abschnitt Unterstützte Dateitypen das Feld Dateityp der neuen Dateizuordnung auf .png. Bei Inhaltsereignissen filtert die automatische Wiedergabe alle Dateitypen heraus, die nicht explizit mit Ihrer Anwendung verknüpft sind.
7. Speichern und schließen Sie die Manifestdatei.

Tabelle 1

Die Einstellung Action Display Name identifiziert die Zeichenfolge, die AutoPlay für Ihre App anzeigt. Die Einstellung Verb identifiziert einen Wert, der für die ausgewählte Option an Ihre App übergeben wird. Sie können mehrere Startaktionen für ein AutoPlay-Ereignis festlegen und die Einstellung Verb verwenden, um festzustellen, welche Option ein Benutzer für Ihre Anwendung ausgewählt hat. Sie können feststellen, welche Option der Benutzer ausgewählt hat, indem Sie die Eigenschaft verb der an Ihre Anwendung übergebenen Startup-Ereignis-Argumente überprüfen. Sie können jeden beliebigen Wert für die Einstellung Verb verwenden, außer open, der reserviert ist.

Tabelle 2

Schritt 2: XAML UI hinzufügen

Öffnen Sie die Datei MainPage.xaml und fügen Sie die folgende XAML zum Standardabschnitt <Grid> hinzu.

<TextBlock FontSize="18">File List</TextBlock>
<TextBlock x:Name="FilesBlock" HorizontalAlignment="Left" TextWrapping="Wrap"
           VerticalAlignment="Top" Margin="0,20,0,0" Height="280" Width="240" />
<Canvas x:Name="FilesCanvas" HorizontalAlignment="Left" VerticalAlignment="Top"
        Margin="260,20,0,0" Height="280" Width="100"/>

Schritt 3: Initialisierungscode hinzufügen

Der Code in diesem Schritt prüft den Verb-Wert in der Eigenschaft Verb, die eines der Startargumente ist, die während des Ereignisses OnFileActivated an die Anwendung übergeben werden. Der Code ruft dann eine Methode auf, die sich auf die vom Benutzer ausgewählte Option bezieht. Für das Kameraspeicherereignis übergibt AutoPlay den Stammordner des Kameraspeichers an die App. Sie können diesen Ordner über das erste Element der Eigenschaft Files abrufen.

Öffnen Sie die Datei App.xaml.cs und fügen Sie den folgenden Code zur Klasse App hinzu.

protected override void OnFileActivated(FileActivatedEventArgs args)
{
    if (args.Verb == "show")
    {
        Frame rootFrame = (Frame)Window.Current.Content;
        MainPage page = (MainPage)rootFrame.Content;

        // Call DisplayImages with root folder from camera storage.
        page.DisplayImages((Windows.Storage.StorageFolder)args.Files[0]);
    }

    if (args.Verb == "copy")
    {
        Frame rootFrame = (Frame)Window.Current.Content;
        MainPage page = (MainPage)rootFrame.Content;

        // Call CopyImages with root folder from camera storage.
        page.CopyImages((Windows.Storage.StorageFolder)args.Files[0]);
    }

    base.OnFileActivated(args);
}

Hinweis Die Methoden DisplayImages und CopyImages werden in den folgenden Schritten hinzugefügt.

Schritt 4: Code zum Anzeigen von Bildern hinzufügen

Fügen Sie in der Datei MainPage.xaml.cs den folgenden Code zur Klasse MainPage hinzu.

async internal void DisplayImages(Windows.Storage.StorageFolder rootFolder)
{
    // Display images from first folder in root\DCIM.
    var dcimFolder = await rootFolder.GetFolderAsync("DCIM");
    var folderList = await dcimFolder.GetFoldersAsync();
    var cameraFolder = folderList[0];
    var fileList = await cameraFolder.GetFilesAsync();
    for (int i = 0; i < fileList.Count; i++)
    {
        var file = (Windows.Storage.StorageFile)fileList[i];
        WriteMessageText(file.Name + "\n");
        DisplayImage(file, i);
    }
}

async private void DisplayImage(Windows.Storage.IStorageItem file, int index)
{
    try
    {
        var sFile = (Windows.Storage.StorageFile)file;
        Windows.Storage.Streams.IRandomAccessStream imageStream =
            await sFile.OpenAsync(Windows.Storage.FileAccessMode.Read);
        Windows.UI.Xaml.Media.Imaging.BitmapImage imageBitmap =
            new Windows.UI.Xaml.Media.Imaging.BitmapImage();
        imageBitmap.SetSource(imageStream);
        var element = new Image();
        element.Source = imageBitmap;
        element.Height = 100;
        Thickness margin = new Thickness();
        margin.Top = index * 100;
        element.Margin = margin;
        FilesCanvas.Children.Add(element);
    }
    catch (Exception e)
    {
       WriteMessageText(e.Message + "\n");
    }
}

// Write a message to MessageBlock on the UI thread.
private Windows.UI.Core.CoreDispatcher messageDispatcher = Window.Current.CoreWindow.Dispatcher;

private async void WriteMessageText(string message, bool overwrite = false)
{
    await messageDispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
        () =>
        {
            if (overwrite)
                FilesBlock.Text = message;
            else
                FilesBlock.Text += message;
        });
}

Schritt 5: Code zum Kopieren von Bildern hinzufügen

Fügen Sie in der Datei MainPage.xaml.cs den folgenden Code zur Klasse MainPage hinzu.

async internal void CopyImages(Windows.Storage.StorageFolder rootFolder)
{
    // Copy images from first folder in root\DCIM.
    var dcimFolder = await rootFolder.GetFolderAsync("DCIM");
    var folderList = await dcimFolder.GetFoldersAsync();
    var cameraFolder = folderList[0];
    var fileList = await cameraFolder.GetFilesAsync();

    try
    {
        var folderName = "Images " + DateTime.Now.ToString("yyyy-MM-dd HHmmss");
        Windows.Storage.StorageFolder imageFolder = await
            Windows.Storage.KnownFolders.PicturesLibrary.CreateFolderAsync(folderName);

        foreach (Windows.Storage.IStorageItem file in fileList)
        {
            CopyImage(file, imageFolder);
        }
    }
    catch (Exception e)
    {
        WriteMessageText("Failed to copy images.\n" + e.Message + "\n");
    }
}

async internal void CopyImage(Windows.Storage.IStorageItem file,
                              Windows.Storage.StorageFolder imageFolder)
{
    try
    {
        Windows.Storage.StorageFile sFile = (Windows.Storage.StorageFile)file;
        await sFile.CopyAsync(imageFolder, sFile.Name);
        WriteMessageText(sFile.Name + " copied.\n");
    }
    catch (Exception e)
    {
        WriteMessageText("Failed to copy file.\n" + e.Message + "\n");
    }
}

Schritt 6: Erstellen und Ausführen der Anwendung

1. Drücken Sie F5, um die Anwendung zu erstellen und bereitzustellen (im Debug-Modus).
2. Um Ihre Anwendung auszuführen, setzen Sie eine Speicherkarte oder ein anderes Speichermedium aus einer Kamera in Ihren PC ein. Wählen Sie dann eine der Inhaltsereignisoptionen, die Sie in der Datei package.appxmanifest angegeben haben, aus der Liste der Optionen für die automatische Wiedergabe aus. Dieser Beispielcode zeigt oder kopiert nur Bilder im DCIM-Ordner einer Kamera-Speicherkarte. Wenn die Speicherkarte Ihrer Kamera Bilder in einem AVCHD- oder PRIVATE\ACHD-Ordner speichert, müssen Sie den Code entsprechend aktualisieren.

Für ein AutoPlay-Gerät registrieren

Sie können Anwendungen als Optionen für AutoPlay-Geräteereignisse registrieren. AutoPlay-Geräteereignisse werden ausgelöst, wenn ein Gerät an einen PC angeschlossen wird.

Hier zeigen wir, wie Sie Ihre App als AutoPlay-Option identifizieren können, wenn eine Kamera mit einem PC verbunden ist. Die Anwendung registriert sich als Handler für das Ereignis WPD\ImageSourceAutoPlay. Dies ist ein häufiges Ereignis, das das Windows Portable Device (WPD)-System auslöst, wenn Kameras und andere bildgebende Geräte ihm mitteilen, dass sie eine ImageSource sind, die MTP verwendet. Weitere Informationen finden Sie unter Windows Portable Devices.

Wichtig Die Windows.Devices.Portable.StorageDevice-APIs sind Teil der Desktop-Gerätefamilie. Apps können diese APIs nur auf Windows 10-Geräten der Desktop-Gerätefamilie, wie z. B. PCs, verwenden.

Schritt 1: Erstellen Sie ein weiteres neues Projekt und fügen Sie AutoPlay-Deklarationen hinzu

1. Öffnen Sie Visual Studio und wählen Sie Neues Projekt aus dem Menü Datei. Wählen Sie im Abschnitt Visual C# unter Windows die Option Blank App (Universal Windows). Nennen Sie die Anwendung AutoPlayDevice_Camera und klicken Sie auf OK.
2. Öffnen Sie die Datei Package.appxmanifest und wählen Sie die Registerkarte Capabilities. Wählen Sie die Funktion Removable Storage. Dadurch erhält die App Zugriff auf die Daten der Kamera als Wechseldatenträger.
3. Wählen Sie in der Manifestdatei die Registerkarte Declarations. Wählen Sie in der Dropdown-Liste Verfügbare Deklarationen die Option AutoPlay Device und klicken Sie auf Hinzufügen. Wählen Sie das neue Element AutoPlay Device aus, das der Liste Unterstützte Deklarationen hinzugefügt wurde.
4. Eine AutoPlay Device-Deklaration identifiziert Ihre App als eine Option, wenn AutoPlay ein Geräteereignis für bekannte Ereignisse auslöst. Geben Sie im Abschnitt Launch Actions die Werte in der folgenden Tabelle für die erste Startaktion ein.
5. Wählen Sie in der Dropdown-Liste Available Declarations die Option File Type Associations und klicken Sie auf Add. Setzen Sie in den Eigenschaften der neuen Deklaration File Type Associations das Feld Display Name auf Show Images from Camera und das Feld Name auf camera_association1. Klicken Sie im Abschnitt Unterstützte Dateitypen auf Neu hinzufügen (falls erforderlich). Setzen Sie das Feld Dateityp auf .jpg. Klicken Sie im Abschnitt Unterstützte Dateitypen erneut auf Neu hinzufügen. Setzen Sie das Feld Dateityp der neuen Dateizuordnung auf .png. Bei Inhaltsereignissen filtert die automatische Wiedergabe alle Dateitypen heraus, die nicht explizit mit Ihrer Anwendung verknüpft sind.
6. Speichern und schließen Sie die Manifestdatei.

Die Einstellung Action Display Name identifiziert die Zeichenfolge, die AutoPlay für Ihre App anzeigt. Die Einstellung Verb identifiziert einen Wert, der für die ausgewählte Option an Ihre App übergeben wird. Sie können mehrere Startaktionen für ein AutoPlay-Ereignis festlegen und die Einstellung Verb verwenden, um festzustellen, welche Option ein Benutzer für Ihre Anwendung ausgewählt hat. Sie können feststellen, welche Option der Benutzer ausgewählt hat, indem Sie die Eigenschaft verb der an Ihre Anwendung übergebenen Startup-Ereignis-Argumente überprüfen. Sie können jeden beliebigen Wert für die Einstellung Verb verwenden, außer open, der reserviert ist. Ein Beispiel für die Verwendung mehrerer Verben in einer einzigen Anwendung finden Sie unter Register for AutoPlay content.

Schritt 2: Assembly-Referenz für die Desktop-Erweiterungen hinzufügen

Die APIs, die für den Zugriff auf Speicher auf einem Windows Portable Device, Windows.Devices.Portable.StorageDevice, benötigt werden, sind Teil der Desktop-Gerätefamilie. Dies bedeutet, dass eine spezielle Baugruppe erforderlich ist, um die APIs zu verwenden, und dass diese Aufrufe nur auf einem Gerät der Desktop-Gerätefamilie (z. B. einem PC) funktionieren.

1. In Projektmappen-Explorer klicken Sie mit der rechten Maustaste auf Referenzen und dann Referenz hinzufügen....
2. Erweitern Sie Universal Windows und klicken Sie auf Erweiterungen.
3. Wählen Sie dann Windows Desktop Extensions for the UWP und klicken Sie auf OK.

Schritt 3: XAML UI hinzufügen

Öffnen Sie die Datei MainPage.xaml und fügen Sie die folgende XAML zum Standardabschnitt <Grid> hinzu.

<StackPanel Orientation="Vertical" Margin="10,0,-10,0">
    <TextBlock FontSize="24">Device Information</TextBlock>
    <StackPanel Orientation="Horizontal">
        <TextBlock x:Name="DeviceInfoTextBlock" FontSize="18" Height="400" Width="400" VerticalAlignment="Top" />
        <ListView x:Name="ImagesList" HorizontalAlignment="Left" Height="400" VerticalAlignment="Top" Width="400">
            <ListView.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Vertical">
                        <Image Source="{Binding Path=Source}" />
                        <TextBlock Text="{Binding Path=Name}" />
                    </StackPanel>
                </DataTemplate>
            </ListView.ItemTemplate>
            <ListView.ItemsPanel>
                <ItemsPanelTemplate>
                    <WrapGrid Orientation="Horizontal" ItemHeight="100" ItemWidth="120"></WrapGrid>
                </ItemsPanelTemplate>
            </ListView.ItemsPanel>
        </ListView>
    </StackPanel>
</StackPanel>

Schritt 4: Aktivierungscode hinzufügen

Der Code in diesem Schritt referenziert die Kamera als StorageDevice indem er die Geräteinformation Id der Kamera an die Methode FromId übergibt. Die Geräteinformations-ID der Kamera wird ermittelt, indem zunächst die Ereignisargumente als DeviceActivatedEventArgs gecastet werden und dann der Wert aus der Eigenschaft DeviceInformationId abgerufen wird.

Öffnen Sie die Datei App.xaml.cs und fügen Sie den folgenden Code zur Klasse App hinzu.

protected override void OnActivated(IActivatedEventArgs args)
{
   if (args.Kind == ActivationKind.Device)
   {
      Frame rootFrame = null;
      // Ensure that the current page exists and is activated
      if (Window.Current.Content == null)
      {
         rootFrame = new Frame();
         rootFrame.Navigate(typeof(MainPage));
         Window.Current.Content = rootFrame;
      }
      else
      {
         rootFrame = Window.Current.Content as Frame;
      }
      Window.Current.Activate();

      // Make sure the necessary APIs are present on the device
      bool storageDeviceAPIPresent =
      Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Devices.Portable.StorageDevice");

      if (storageDeviceAPIPresent)
      {
         // Reference the current page as type MainPage
         var mPage = rootFrame.Content as MainPage;

         // Cast the activated event args as DeviceActivatedEventArgs and show images
         var deviceArgs = args as DeviceActivatedEventArgs;
         if (deviceArgs != null)
         {
            mPage.ShowImages(Windows.Devices.Portable.StorageDevice.FromId(deviceArgs.DeviceInformationId));
         }
      }
      else
      {
         // Handle case where APIs are not present (when the device is not part of the desktop device family)
      }

   }

   base.OnActivated(args);
}

Schritt 5: Code zur Anzeige von Geräteinformationen hinzufügen

Sie können Informationen über die Kamera aus den Eigenschaften der Klasse StorageDevice erhalten. Der Code in diesem Schritt zeigt dem Benutzer den Gerätenamen und andere Informationen an, wenn die Anwendung ausgeführt wird. Der Code ruft dann die Methoden GetImageList und GetThumbnail auf, die Sie im nächsten Schritt hinzufügen werden, um Vorschauminiaturen der auf der Kamera gespeicherten Bilder anzuzeigen

Fügen Sie in der Datei MainPage.xaml.cs den folgenden Code zur Klasse MainPage hinzu.

private Windows.Storage.StorageFolder rootFolder;

internal async void ShowImages(Windows.Storage.StorageFolder folder)
{
    DeviceInfoTextBlock.Text = "Display Name = " + folder.DisplayName + "\n";
    DeviceInfoTextBlock.Text += "Display Type =  " + folder.DisplayType + "\n";
    DeviceInfoTextBlock.Text += "FolderRelativeId = " + folder.FolderRelativeId + "\n";

    // Reference first folder of the device as the root
    rootFolder = (await folder.GetFoldersAsync())[0];
    var imageList = await GetImageList(rootFolder);

    foreach (Windows.Storage.StorageFile img in imageList)
    {
        ImagesList.Items.Add(await GetThumbnail(img));
    }
}

Schritt 6: Code zum Anzeigen von Bildern hinzufügen

Der Code in diesem Schritt zeigt Vorschauminiaturen der auf der Kamera gespeicherten Bilder an. Der Code führt asynchrone Aufrufe an die Kamera durch, um das Miniaturbild zu erhalten. Der nächste asynchrone Aufruf erfolgt jedoch erst, wenn der vorherige asynchrone Aufruf abgeschlossen ist. Dadurch wird sichergestellt, dass jeweils nur eine Anfrage an die Kamera gestellt wird.

Fügen Sie in der Datei MainPage.xaml.cs den folgenden Code zur Klasse MainPage hinzu.

async private System.Threading.Tasks.Task<List<Windows.Storage.StorageFile>> GetImageList(Windows.Storage.StorageFolder folder)
{
    var result = await folder.GetFilesAsync();
    var subFolders = await folder.GetFoldersAsync();
    foreach (Windows.Storage.StorageFolder f in subFolders)
        result = result.Union(await GetImageList(f)).ToList();

    return (from f in result orderby f.Name select f).ToList();
}

async private System.Threading.Tasks.Task<Image> GetThumbnail(Windows.Storage.StorageFile img)
{
    // Get the thumbnail to display
    var thumbnail = await img.GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.SingleItem,
                                                100,
                                                Windows.Storage.FileProperties.ThumbnailOptions.UseCurrentScale);

    // Create a XAML Image object bind to on the display page
    var result = new Image();
    result.Height = thumbnail.OriginalHeight;
    result.Width = thumbnail.OriginalWidth;
    result.Name = img.Name;
    var imageBitmap = new Windows.UI.Xaml.Media.Imaging.BitmapImage();
    imageBitmap.SetSource(thumbnail);
    result.Source = imageBitmap;

    return result;
}

Schritt 7: Erstellen und Ausführen der Anwendung

1. Drücken Sie F5, um die Anwendung zu erstellen und bereitzustellen (im Debug-Modus).
2. Um Ihre Anwendung auszuführen, schließen Sie eine Kamera an Ihr Gerät an. Wählen Sie dann die App aus der Liste der AutoPlay-Optionen aus.

Konfigurieren von Wechselspeichern

Sie können ein Volume-Gerät wie eine Speicherkarte oder ein USB-Stick als AutoPlay-Gerät identifizieren, wenn das Volume-Gerät an einen PC angeschlossen ist. Dies ist besonders nützlich, wenn Sie eine bestimmte App für AutoPlay zuordnen möchten, um sie dem Benutzer für Ihr Volume-Gerät zu präsentieren.

Hier zeigen wir Ihnen, wie Sie Ihr Volume-Gerät als AutoPlay-Gerät identifizieren.

Um Ihr Volume-Gerät als AutoPlay-Gerät zu identifizieren, fügen Sie eine autorun.inf-Datei zum Stammlaufwerk Ihres Geräts hinzu. Fügen Sie in der Datei autorun.inf einen Schlüssel CustomEvent zum Abschnitt AutoRun hinzu. Wenn Ihr Volume-Gerät mit einem PC verbunden wird, findet AutoPlay die Datei autorun.inf und behandelt Ihr Volume als Gerät. AutoPlay erstellt ein AutoPlay-Ereignis unter Verwendung des Namens, den Sie für den CustomEvent-Schlüssel angegeben haben. Sie können dann eine App erstellen und die App als Handler für das Ereignis AutoPlay registrieren. Wenn das Gerät mit dem PC verbunden ist, zeigt AutoPlay Ihre App als Handler für Ihr Volume-Gerät an. Weitere Informationen zu autorun.inf-Dateien finden Sie unter autorun.inf-Einträge.

Schritt 1: Eine autorun.inf-Datei erstellen

Fügen Sie im Stammlaufwerk Ihres Datenträgers eine Datei namens autorun.inf hinzu. Öffnen Sie die Datei autorun.inf und fügen Sie den folgenden Text hinzu.

[AutoRun]
CustomEvent=AutoPlayCustomEventQuickstart

Schritt 2: Erstellen Sie ein neues Projekt und fügen Sie AutoPlay-Deklarationen hinzu

1. Öffnen Sie Visual Studio und wählen Sie Neues Projekt aus dem Menü Datei. Wählen Sie im Abschnitt Visual C# unter Windows die Option Blank App (Universal Windows). Nennen Sie die Anwendung AutoPlayCustomEvent und klicken Sie auf OK.
2. Öffnen Sie die Datei Package.appxmanifest und wählen Sie die Registerkarte Capabilities. Wählen Sie die Funktion Removable Storage. Dadurch erhält die App Zugriff auf die Dateien und Ordner auf Wechseldatenträgern.
3. Wählen Sie in der Manifestdatei die Registerkarte Declarations. Wählen Sie in der Dropdown-Liste Verfügbare Erklärungen die Option AutoPlay Content und klicken Sie auf Add. Wählen Sie das neue Element AutoPlay Content, das der Liste Supported Declarations hinzugefügt wurde.

4. Geben Sie im Abschnitt Launch Actions für Ihre AutoPlay Content Ereignisdeklaration die Werte in der folgenden Tabelle für die erste Startaktion ein.
5. Wählen Sie in der Dropdown-Liste Available Declarations die Option File Type Associations und klicken Sie auf Add. Setzen Sie in den Eigenschaften der neuen Deklaration File Type Associations das Feld Display Name auf Show .ms Files und das Feld Name auf ms_association. Klicken Sie im Abschnitt Unterstützte Dateitypen auf Neu hinzufügen. Setzen Sie das Feld Dateityp auf .ms. Bei Inhaltsereignissen filtert die automatische Wiedergabe alle Dateitypen heraus, die nicht explizit mit Ihrer Anwendung verknüpft sind.
6. Speichern und schließen Sie die Manifestdatei.

Der Wert Content Event ist der Text, den Sie für den Schlüssel CustomEvent in der Datei autorun.inf angegeben haben. Die Einstellung Action Display Name identifiziert die Zeichenfolge, die AutoPlay für Ihre App anzeigt. Die Einstellung Verb identifiziert einen Wert, der für die ausgewählte Option an Ihre App übergeben wird. Sie können mehrere Startaktionen für ein AutoPlay-Ereignis festlegen und die Einstellung Verb verwenden, um festzustellen, welche Option ein Benutzer für Ihre Anwendung ausgewählt hat. Sie können feststellen, welche Option der Benutzer ausgewählt hat, indem Sie die Eigenschaft verb der an Ihre Anwendung übergebenen Startup-Ereignis-Argumente überprüfen. Sie können jeden beliebigen Wert für die Einstellung Verb verwenden, außer open, der reserviert ist.

Schritt 3: Hinzufügen der XAML-Benutzeroberfläche

Öffnen Sie die Datei MainPage.xaml und fügen Sie die folgende XAML zum Standardabschnitt <Grid> hinzu.

<StackPanel Orientation="Vertical">
    <TextBlock FontSize="28" Margin="10,0,800,0">Files</TextBlock>
    <TextBlock x:Name="FilesBlock" FontSize="22" Height="600" Margin="10,0,800,0" />
</StackPanel>

Schritt 4: Hinzufügen des Aktivierungscodes

Der Code in diesem Schritt ruft eine Methode auf, um die Ordner im Stammlaufwerk Ihres Volume-Geräts anzuzeigen. Für die AutoPlay-Inhaltsereignisse übergibt AutoPlay den Stammordner des Speichergeräts in den Startargumenten, die während des Ereignisses OnFileActivated an die Anwendung übergeben werden. Sie können diesen Ordner über das erste Element der Eigenschaft Files abrufen.

Öffnen Sie die Datei App.xaml.cs und fügen Sie den folgenden Code zur Klasse App hinzu.

protected override void OnFileActivated(FileActivatedEventArgs args)
{
    var rootFrame = Window.Current.Content as Frame;
    var page = rootFrame.Content as MainPage;

    // Call ShowFolders with root folder from device storage.
    page.DisplayFiles(args.Files[0] as Windows.Storage.StorageFolder);

    base.OnFileActivated(args);
}

Schritt 5: Code zur Anzeige von Ordnern hinzufügen

Fügen Sie in der Datei MainPage.xaml.cs den folgenden Code zur Klasse MainPage hinzu.

internal async void DisplayFiles(Windows.Storage.StorageFolder folder)
{
    foreach (Windows.Storage.StorageFile f in await ReadFiles(folder, ".ms"))
    {
        FilesBlock.Text += "  " + f.Name + "\n";
    }
}

internal async System.Threading.Tasks.Task<IReadOnlyList<Windows.Storage.StorageFile>>
    ReadFiles(Windows.Storage.StorageFolder folder, string fileExtension)
{
    var options = new Windows.Storage.Search.QueryOptions();
    options.FileTypeFilter.Add(fileExtension);
    var query = folder.CreateFileQueryWithOptions(options);
    var files = await query.GetFilesAsync();

    return files;
}

Schritt 6: Erstellen und Ausführen der Anwendung

1. Drücken Sie F5, um die Anwendung zu erstellen und bereitzustellen (im Debug-Modus).
2. Um Ihre Anwendung auszuführen, setzen Sie eine Speicherkarte oder ein anderes Speichergerät in Ihren PC ein. Wählen Sie dann Ihre Anwendung aus der Liste der AutoPlay-Handler-Optionen aus.

AutoPlay-Ereignis-Referenz

Das AutoPlay-System ermöglicht es Anwendungen, sich für eine Vielzahl von Geräte- und Datenträger-Ereignissen zu registrieren. Um sich für AutoPlay-Inhaltsereignisse zu registrieren, müssen Sie die Funktion Wechselspeicher in Ihrem Paketmanifest aktivieren. Diese Tabelle zeigt die Ereignisse, für die Sie sich anmelden können, und wann sie ausgelöst werden.

Sie können festlegen, dass AutoPlay ein benutzerdefiniertes AutoPlay-Inhaltsereignis auslöst, indem Sie den Eintrag CustomEvent in der Datei autorun.inf für ein Volume verwenden. Weitere Informationen finden Sie unter Autorun.inf-Einträge.

Sie können Ihre Anwendung als AutoPlay Content- oder AutoPlay Device-Ereignishandler registrieren, indem Sie eine Erweiterung zur package.appxmanifest-Datei für Ihre Anwendung hinzufügen. Wenn Sie Visual Studio verwenden, können Sie eine AutoPlay Content oder AutoPlay Device-Deklaration auf der Registerkarte Declarations hinzufügen. Wenn Sie die Datei package.appxmanifest für Ihre Anwendung direkt bearbeiten, fügen Sie ein Extension-Element zu Ihrem Paketmanifest hinzu, das entweder windows.autoPlayContent oder windows.autoPlayDevice als Kategorie angibt. Der folgende Eintrag im Paketmanifest fügt zum Beispiel eine AutoPlay Content-Erweiterung hinzu, um die App als Handler für das ShowPicturesOnArrival-Ereignis zu registrieren.

  <Applications>
    <Application Id="AutoPlayHandlerSample.App">
      <Extensions>
        <Extension Category="windows.autoPlayContent">
          <AutoPlayContent>
            <LaunchAction Verb="show" ActionDisplayName="Show Pictures"
                          ContentEvent="ShowPicturesOnArrival" />
          </AutoPlayContent>
        </Extension>
      </Extensions>
    </Application>
  </Applications>