MedienumwandlungMedia casting

In diesem Artikel wird beschrieben, wie Sie Medien aus einer universellen Windows-App zu Remotegeräten umwandeln.This article shows you how to cast media to remote devices from a Universal Windows app.

Integrierte Medienumwandlung mit MediaPlayerElementBuilt-in media casting with MediaPlayerElement

Die einfachste Methode zum Umwandeln von Medien aus einer universellen Windows-App ist die Verwendung der integrierten Umwandlungsfunktion des MediaPlayerElement-Steuerelements.The simplest way to cast media from a Universal Windows app is to use the built-in casting capability of the MediaPlayerElement control.

Um dem Benutzer das Öffnen einer wiederzugebenden Videodatei im MediaPlayerElement-Steuerelement zu ermöglichen, fügen Sie Ihrem Projekt die folgenden Namespaces hinzu.To allow the user to open a video file to be played in the MediaPlayerElement control, add the following namespaces to your project.

using Windows.Storage;
using Windows.Storage.Pickers;
using Windows.Storage.Streams;
using Windows.Media.Core;

Fügen Sie in der XAML-Datei der App ein MediaPlayerElement hinzu, und legen Sie AreTransportControlsEnabled auf „true“ fest.In your app's XAML file, add a MediaPlayerElement and set AreTransportControlsEnabled to true.

<MediaPlayerElement Name="mediaPlayerElement"  MinHeight="100" MaxWidth="600" HorizontalAlignment="Stretch" AreTransportControlsEnabled="True"/>

Fügen Sie eine Schaltfläche hinzu, über die der Benutzer die Auswahl einer Datei initiieren kann.Add a button to let the user initiate picking a file.

<Button x:Name="openButton" Click="openButton_Click" Content="Open"/>

Erstellen Sie im Click-Ereignishandler für die Schaltfläche eine neue Instanz des FileOpenPicker-Objekts, fügen Sie der FileTypeFilter-Sammlung Videodateitypen hinzu, und legen die Ausgangsposition auf die Videobibliothek des Benutzers fest.In the Click event handler for the button, create a new instance of the FileOpenPicker, add video file types to the FileTypeFilter collection, and set the starting location to the user's videos library.

Rufen Sie PickSingleFileAsync auf, um das Dialogfeld für die Dateiauswahl zu starten.Call PickSingleFileAsync to launch the file picker dialog. Diese Methode gibt ein StorageFile-Objekt zurück, das die Videodatei darstellt.When this method returns, the result is a StorageFile object representing the video file. Stellen Sie sicher, dass die Datei nicht NULL ist; dies ist der Fall, wenn der Benutzer den Auswahlvorgang abbricht.Check to make sure the file isn't null, which it will be if the user cancels the picking operation. Rufen Sie die OpenAsync-Methode der Datei auf, um einen IRandomAccessStream für die Datei abzurufen.Call the file's OpenAsync method to get an IRandomAccessStream for the file. Abschließend erstellen Sie ein neues MediaSource-Objekt aus der ausgewählten Datei durch Aufrufen von CreateFromStorageFile und weisen es der Source-Eigenschaft des MediaPlayerElement-Objekts zu, um die Videodatei zur Videoquelle für das Steuerelement zu machen.Finally, create a new MediaSource object from the selected file by calling CreateFromStorageFile and assign it to the MediaPlayerElement object's Source property to make the video file the video source for the control.

private async void openButton_Click(object sender, RoutedEventArgs e)
{
    //Create a new picker
    FileOpenPicker filePicker = new FileOpenPicker();

    //Add filetype filters.  In this case wmv and mp4.
    filePicker.FileTypeFilter.Add(".wmv");
    filePicker.FileTypeFilter.Add(".mp4");

    //Set picker start location to the video library
    filePicker.SuggestedStartLocation = PickerLocationId.VideosLibrary;

    //Retrieve file from picker
    StorageFile file = await filePicker.PickSingleFileAsync();

    //If we got a file, load it into the media lement
    if (file != null)
    {
        mediaPlayerElement.Source = MediaSource.CreateFromStorageFile(file);
        mediaPlayerElement.MediaPlayer.Play();
    }
}

Nachdem das Video in das MediaPlayerElement geladen wurde, kann der Benutzer einfach die Umwandlungsschaltfläche in den Transportsteuerelementen wählen, um ein integriertes Dialogfeld zu öffnen, in dem er ein Gerät auswählen kann, für das die geladenen Medien umgewandelt werden.Once the video is loaded in the MediaPlayerElement, the user can simply press the casting button on the transport controls to launch a built-in dialog that allows them to choose a device to which the loaded media will be cast.

MediaElement-Umwandlungsschaltfläche

Hinweis

Ab Windows 10, Version 1607, wird die Verwendung der MediaPlayer-Klasse zum Wiedergeben von Medienelementen empfohlen.Starting with Windows 10, version 1607, it is recommended that you use the MediaPlayer class to play media items. MediaPlayerElement ist ein einfaches XAML-Steuerelement, das zum Rendern des Inhalts eines MediaPlayer-Objekts auf einer XAML-Seite verwendet wird.The MediaPlayerElement is a lightweight XAML control that is used to render the content of a MediaPlayer in a XAML page. Das MediaElement-Steuerelement wird aus Gründen der Abwärtskompatibilität weiterhin unterstützt.The MediaElement control continues to be supported for backwards compatibility. Weitere Informationen zur Verwendung von MediaPlayer und MediaPlayerElement zum Wiedergeben von Medieninhalten finden Sie unter Wiedergeben von Audio- und Videoinhalten mit „MediaPlayer“.For more information on using MediaPlayer and MediaPlayerElement to play media content, see Play audio and video with MediaPlayer. Informationen zur Verwendung von MediaSource und dazugehörigen APIs für die Arbeit mit Medieninhalten finden Sie unter Medienelemente, Wiedergabelisten und Titel.For information on using MediaSource and related APIs to work with media content, see Media items, playlists, and tracks.

Medienumwandlung mit CastingDevicePickerMedia casting with the CastingDevicePicker

Eine zweite Methode zum Umwandeln von Medien für ein Gerät ist die Verwendung der CastingDevicePicker-Klasse.A second way to cast media to a device is to use the CastingDevicePicker. Zum Verwenden dieser Klasse schließen Sie den Windows.Media.Casting-Namespace in Ihr Projekt ein.To use this class, include the Windows.Media.Casting namespace in your project.

using Windows.Media.Casting;

Deklarieren Sie eine Membervariable für das CastingDevicePicker-Objekt.Declare a member variable for the CastingDevicePicker object.

CastingDevicePicker castingPicker;

Wenn die Seite initialisiert wird, erstellen Sie eine neue Instanz der Umwandlungsauswahl, und legen Sie die Filter-Eigenschaft auf SupportsVideo fest, um anzugeben, dass die von der Auswahl aufgeführten Umwandlungsgeräte Video unterstützen müssen.When you page is initialized, create a new instance of the casting picker and set the Filter to SupportsVideo property to indicate that the casting devices listed by the picker should support video. Registrieren Sie einen Handler für das CastingDeviceSelected-Ereignis, das ausgelöst wird, wenn der Benutzer ein Gerät für die Umwandlung auswählt.Register a handler for the CastingDeviceSelected event, which is raised when the user picks a device for casting.

//Initialize our picker object
castingPicker = new CastingDevicePicker();

//Set the picker to filter to video capable casting devices
castingPicker.Filter.SupportsVideo = true;

//Hook up device selected event
castingPicker.CastingDeviceSelected += CastingPicker_CastingDeviceSelected;

Fügen Sie in der XAML-Datei eine Schaltfläche hinzu, über die der Benutzer die Auswahl starten kann.In your XAML file, add a button to allow the user to launch the picker.

<Button x:Name="castPickerButton" Content="Cast Button" Click="castPickerButton_Click"/>

Rufen Sie im Click-Ereignishandler für die Schaltfläche TransformToVisual auf, um die Transformation eines UI-Elements relativ zu einem anderen Element abzurufen.In the Click event handler for the button, call TransformToVisual to get the transform of a UI element relative to another element. In diesem Beispiel ist die Transformation die Position der Umwandlungsauswahl-Schaltfläche relativ zum visuellen Stamm des Anwendungsfensters.In this example, the transform is the position of the cast picker button relative to the visual root of the application window. Rufen Sie die Show-Methode des CastingDevicePicker-Objekts auf, um das Dialogfeld der Umwandlungsauswahl zu öffnen.Call the Show method of the CastingDevicePicker object to launch the casting picker dialog. Geben Sie die Position und die Abmessungen der Umwandlungsauswahl-Schaltfläche an, sodass das Dialogfeld als Flyout der vom Benutzer gewählten Schaltfläche angezeigt werden kann.Specify the location and dimensions of the cast picker button so that the system can make the dialog fly out from the button that the user pressed.

private void castPickerButton_Click(object sender, RoutedEventArgs e)
{
    //Retrieve the location of the casting button
    GeneralTransform transform = castPickerButton.TransformToVisual(Window.Current.Content as UIElement);
    Point pt = transform.TransformPoint(new Point(0, 0));

    //Show the picker above our casting button
    castingPicker.Show(new Rect(pt.X, pt.Y, castPickerButton.ActualWidth, castPickerButton.ActualHeight),
        Windows.UI.Popups.Placement.Above);
}

Rufen Sie im CastingDeviceSelected-Ereignishandler die CreateCastingConnection-Methode der SelectedCastingDevice-Eigenschaft der Ereignisargumente auf, die das vom Benutzer ausgewählte Umwandlungsgerät darstellt.In the CastingDeviceSelected event handler, call the CreateCastingConnection method of the SelectedCastingDevice property of the event args, which represents the casting device selected by the user. Registrieren Sie Handler für die Ereignisse ErrorOccurred und StateChanged.Register handlers for the ErrorOccurred and StateChanged events. Rufen Sie abschließend RequestStartCastingAsync auf, um die Umwandlung zu starten, indem das Ergebnis für die GetAsCastingSource-Methode des MediaPlayer-Objekts des MediaPlayerElement-Steuerelements übergeben wird, um anzugeben, dass die Medien, die umgewandelt werden sollen, der Inhalt des MediaPlayer sind, der dem MediaPlayerElement zugeordnet ist.Finally, call RequestStartCastingAsync to begin casting, passing in the result to the MediaPlayerElement control's MediaPlayer object's GetAsCastingSource method to specify that the media to be cast is the content of the MediaPlayer associated with the MediaPlayerElement.

Hinweis

Die Umwandlungsverbindung muss im UI-Thread initiiert werden.The casting connection must be initiated on the UI thread. Da CastingDeviceSelected nicht für den UI-Thread aufgerufen wird, müssen Sie diese Aufrufe innerhalb eines Aufrufs von CoreDispatcher.RunAsync platzieren, sodass diese für den UI-Thread aufgerufen werden.Since the CastingDeviceSelected is not called on the UI thread, you must place these calls inside a call to CoreDispatcher.RunAsync which causes them to be called on the UI thread.

private async void CastingPicker_CastingDeviceSelected(CastingDevicePicker sender, CastingDeviceSelectedEventArgs args)
{
    //Casting must occur from the UI thread.  This dispatches the casting calls to the UI thread.
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
    {
        //Create a casting conneciton from our selected casting device
        CastingConnection connection = args.SelectedCastingDevice.CreateCastingConnection();

        //Hook up the casting events
        connection.ErrorOccurred += Connection_ErrorOccurred;
        connection.StateChanged += Connection_StateChanged;

        //Cast the content loaded in the media element to the selected casting device
        await connection.RequestStartCastingAsync(mediaPlayerElement.MediaPlayer.GetAsCastingSource());
    });
}

Aktualisieren Sie die Benutzeroberfläche in den Ereignishandlern ErrorOccurred und StateChanged, um den Benutzer über den aktuellen Status der Umwandlung zu informieren.In the ErrorOccurred and StateChanged event handlers, you should update your UI to inform the user of the current casting status. Diese Ereignisse werden im folgenden Abschnitt zum Erstellen einer benutzerdefinierten Umwandlungsgeräteauswahl ausführlich erläutert.These events are discussed in detail in the following section on creating a custom casting device picker.

private async void Connection_StateChanged(CastingConnection sender, object args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        ShowMessageToUser("Casting Connection State Changed: " + sender.State);
    });
}

private async void Connection_ErrorOccurred(CastingConnection sender, CastingConnectionErrorOccurredEventArgs args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        ShowMessageToUser("Casting Connection State Changed: " + sender.State);
    });
}

Medienumwandlung mit einer benutzerdefinierten GeräteauswahlMedia casting with a custom device picker

Im folgenden Abschnitt wird beschrieben, wie Sie ein eigenes Benutzeroberflächenelement zur Umwandlungsgeräteauswahl erstellen, indem Sie die Umwandlungsgeräte aufzählen und die Verbindung im Code initiieren.The following section describes how to create your own casting device picker UI by enumerating the casting devices and initiating the connection from your code.

Um die verfügbaren Umwandlungsgeräte aufzuzählen, schließen Sie den Windows.Devices.Enumeration-Namespace in Ihr Projekt ein.To enumerate the available casting devices, include the Windows.Devices.Enumeration namespace in your project.

using Windows.Devices.Enumeration;

Fügen Sie der XAML-Seite die folgenden Steuerelemente hinzu, um die einfache Benutzeroberfläche für dieses Beispiel zu implementieren:Add the following controls to your XAML page to implement the rudimentary UI for this example:

  • Eine Schaltfläche zum Starten des Geräteüberwachungselements, das nach verfügbaren Umwandlungsgeräten sucht.A button to start the device watcher that looks for available casting devices.
  • Ein ProgressRing-Steuerelement, das den Benutzer über die laufende Umwandlungsenumeration informiert.A ProgressRing control to provide feedback to the user that casting enumeration is ongoing.
  • Ein ListBox zum Auflisten der erkannten Umwandlungsgeräte.A ListBox to list the discovered casting devices. Definieren Sie eine ItemTemplate für das Steuerelement, sodass die Umwandlungsgeräteobjekte direkt dem Steuerelement zugewiesen werden können und die FriendlyName-Eigenschaft trotzdem weiterhin angezeigt wird.Define an ItemTemplate for the control so that we can assign the casting device objects directly to the control and still display the FriendlyName property.
  • Eine Schaltfläche, über die der Benutzer das Umwandlungsgerät trennen kann.A button to allow the user to disconnect the casting device.
<Button x:Name="startWatcherButton" Content="Watcher Button" Click="startWatcherButton_Click"/>
<ProgressRing x:Name="watcherProgressRing" IsActive="False"/>
<ListBox x:Name="castingDevicesListBox" MaxWidth="300" HorizontalAlignment="Left" SelectionChanged="castingDevicesListBox_SelectionChanged">
    <!--Listbox content is bound to the FriendlyName field of our casting devices-->
    <ListBox.ItemTemplate>
        <DataTemplate>
            <TextBlock Text="{Binding Path=FriendlyName}"/>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>
<Button x:Name="disconnectButton" Content="Disconnect" Click="disconnectButton_Click" Visibility="Collapsed"/>

Deklarieren Sie im CodeBehind Membervariablen für DeviceWatcher und CastingConnection.In your code behind, declare member variables for the DeviceWatcher and the CastingConnection.

DeviceWatcher deviceWatcher;
CastingConnection castingConnection;

Aktualisieren Sie im Click-Handler für die startWatcherButton zuerst die Benutzeroberfläche, indem Sie die Schaltfläche deaktivieren und das Statussignal aktivieren, während die Geräteenumeration ausgeführt wird.In the Click handler for the startWatcherButton, first update the UI by disabling the button and making the progress ring active while device enumeration is ongoing. Löschen Sie den Inhalt des Listenfelds mit Umwandlungsgeräten.Clear the list box of casting devices.

Erstellen Sie als Nächstes ein Geräteüberwachungselement durch Aufruf von DeviceInformation.CreateWatcher.Next, create a device watcher by calling DeviceInformation.CreateWatcher. Diese Methode kann verwendet werden, um viele verschiedene Arten von Geräten zu überwachen.This method can be used to watch for many different types of devices. Geben Sie mithilfe der von CastingDevice.GetDeviceSelector zurückgegebenen Geräteauswahlzeichenfolge an, dass Sie Geräte überwachen möchten, die die Videoumwandlung unterstützen.Specify that you want to watch for devices that support video casting by using the device selector string returned by CastingDevice.GetDeviceSelector.

Registrieren Sie abschließend Ereignishandler für die Ereignisse Added, Removed, EnumerationCompleted und Stopped.Finally, register event handlers for the Added, Removed, EnumerationCompleted, and Stopped events.

private void startWatcherButton_Click(object sender, RoutedEventArgs e)
{
    startWatcherButton.IsEnabled = false;
    watcherProgressRing.IsActive = true;

    castingDevicesListBox.Items.Clear();

    //Create our watcher and have it find casting devices capable of video casting
    deviceWatcher = DeviceInformation.CreateWatcher(CastingDevice.GetDeviceSelector(CastingPlaybackTypes.Video));

    //Register for watcher events
    deviceWatcher.Added += DeviceWatcher_Added;
    deviceWatcher.Removed += DeviceWatcher_Removed;
    deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
    deviceWatcher.Stopped += DeviceWatcher_Stopped;

    //Start the watcher
    deviceWatcher.Start();
}

Das Added-Ereignis wird ausgelöst, wenn ein neues Gerät vom Überwachungselement erkannt wird.The Added event is raised when a new device is discovered by the watcher. Erstellen Sie im Handler für dieses Ereignis ein neues CastingDevice-Objekt, indem Sie CastingDevice.FromIdAsync aufrufen und die ID des erkannten Umwandlungsgeräts übergeben, die in dem an den Handler übergebenen DeviceInformation-Objekt enthalten ist.In the handler for this event, create a new CastingDevice object by calling CastingDevice.FromIdAsync and passing in the ID of the discovered casting device, which is contained in the DeviceInformation object passed into the handler.

Fügen Sie das CastingDevice zum ListBox für Umwandlungsgeräte hinzu, damit der Benutzer es auswählen kann.Add the CastingDevice to the casting device ListBox so that the user can select it. Aufgrund der in XAML definierten ItemTemplate wird die FriendlyName-Eigenschaft als Elementtext im Listenfeld verwendet.Because of the ItemTemplate defined in the XAML, the FriendlyName property will be used as the item text for in the list box. Da dieser Ereignishandler nicht für den UI-Thread aufgerufen wird, müssen Sie die Benutzeroberfläche innerhalb eines Aufrufs von CoreDispatcher.RunAsync aktualisieren.Because this event handler is not called on the UI thread, you must update the UI from within a call to CoreDispatcher.RunAsync.

private async void DeviceWatcher_Added(DeviceWatcher sender, DeviceInformation args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
    {
        //Add each discovered device to our listbox
        CastingDevice addedDevice = await CastingDevice.FromIdAsync(args.Id);
        castingDevicesListBox.Items.Add(addedDevice);
    });
}

Das Removed-Ereignis wird ausgelöst, wenn das Überwachungselement erkennt, dass ein Umwandlungsgerät nicht mehr vorhanden ist.The Removed event is raised when the watcher detects that a casting device is no longer present. Vergleichen Sie die ID-Eigenschaft des Added-Objekts, die an den Handler übergeben wird, mit der ID jedes Added-Objekts in der Items-Sammlung des Listenfelds.Compare the ID property of the Added object passed into the handler to the ID of each Added in the list box's Items collection. Wenn die ID übereinstimmt, entfernen Sie das Objekt aus der Sammlung.If the ID matches, remove that object from the collection. Zur Erinnerung: Da die Benutzeroberfläche aktualisiert wird, muss dieser Aufruf innerhalb eines RunAsync-Aufrufs erfolgen.Again, because the UI is being updated, this call must be made from within a RunAsync call.

private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        foreach (CastingDevice currentDevice in castingDevicesListBox.Items)
        {
            if (currentDevice.Id == args.Id)
            {
                castingDevicesListBox.Items.Remove(currentDevice);
            }
        }
    });
}

Das EnumerationCompleted-Ereignis wird ausgelöst, wenn das Überwachungselement die Erkennung von Geräten abgeschlossen hat.The EnumerationCompleted event is raised when the watcher has finished detecting devices. Aktualisieren Sie im Handler für dieses Ereignis die Benutzeroberfläche, um den Benutzer darüber zu informieren, dass die Enumeration abgeschlossen ist, und beenden Sie das Geräteüberwachungselement durch Aufruf von Stop.In the handler for this event, update the UI to let the user know that device enumeration has completed and stop the device watcher by calling Stop.

private async void DeviceWatcher_EnumerationCompleted(DeviceWatcher sender, object args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        //If enumeration completes, update UI and transition watcher to the stopped state
        ShowMessageToUser("Watcher completed enumeration of devices");
        deviceWatcher.Stop();
    });
}

Das Stopped-Ereignis wird ausgelöst, wenn das Beenden des Geräteüberwachungselements abgeschlossen ist.The Stopped event is raised when the device watcher has finished stopping. Beenden Sie im Handler für dieses Ereignis das ProgressRing-Steuerelement, und aktivieren Sie die startWatcherButton wieder, damit der Benutzer den Vorgang der Geräteenumeration neu starten kann.In the handler for this event, stop the ProgressRing control and reenable the startWatcherButton so that the user can restart the device enumeration process.

private async void DeviceWatcher_Stopped(DeviceWatcher sender, object args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        //Update UX when the watcher stops
        startWatcherButton.IsEnabled = true;
        watcherProgressRing.IsActive = false;
    });
}

Wenn der Benutzer eines der Umwandlungsgeräte im Listenfeld auswählt, wird das SelectionChanged-Ereignis ausgelöst.When the user selects one of the casting devices from the list box, the SelectionChanged event is raised. Innerhalb dieses Handlers werden die Umwandlungsverbindung erstellt und die Umwandlung gestartet.It is within this handler that the casting connection will be created and casting will be started.

Stellen Sie zunächst sicher, dass das Geräteüberwachungselement beendet wurde, sodass kein Konflikt zwischen Geräteenumeration und Medienumwandlung auftritt.First, make sure the device watcher is stopped so that device enumeration doesn't interfere with media casting. Erstellen Sie eine Umwandlungsverbindung, indem Sie CreateCastingConnection für das vom Benutzer ausgewählte CastingDevice-Objekt aufrufen.Create a casting connection by calling CreateCastingConnection on the CastingDevice object selected by the user. Fügen Sie Ereignishandler für die Ereignisse StateChanged und ErrorOccurred hinzu.Add event handlers for the StateChanged and ErrorOccurred events.

Starten Sie die Medienumwandlung durch Aufrufen von RequestStartCastingAsync, und übergeben Sie dabei die Umwandlungsquelle, die durch den Aufruf der MediaPlayer-Methode GetAsCastingSource zurückgegeben wurde.Start media casting by calling RequestStartCastingAsync, passing in the casting source returned by calling the MediaPlayer method GetAsCastingSource. Machen Sie zum Schluss die Schaltfläche zum Trennen sichtbar, damit der Benutzer die Medienumwandlung beenden kann.Finally, make the disconnect button visible to allow the user to stop media casting.

private async void castingDevicesListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (castingDevicesListBox.SelectedItem != null)
    {
        //When a device is selected, first thing we do is stop the watcher so it's search doesn't conflict with streaming
        if (deviceWatcher.Status != DeviceWatcherStatus.Stopped)
        {
            deviceWatcher.Stop();
        }

        //Create a new casting connection to the device that's been selected
        castingConnection = ((CastingDevice)castingDevicesListBox.SelectedItem).CreateCastingConnection();

        //Register for events
        castingConnection.ErrorOccurred += Connection_ErrorOccurred;
        castingConnection.StateChanged += Connection_StateChanged;

        //Cast the loaded video to the selected casting device.
        await castingConnection.RequestStartCastingAsync(mediaPlayerElement.MediaPlayer.GetAsCastingSource());
        disconnectButton.Visibility = Visibility.Visible;
    }
}

Im Ereignishandler für geänderten Zustand hängt die ausgeführte Aktion vom neuen Zustand der Umwandlungsverbindung ab:In the state changed handler, the action you take depends on the new state of the casting connection:

  • Beim Zustand Connected oder Rendering stellen Sie sicher, dass das ProgressRing-Steuerelement inaktiv ist und die Schaltfläche zum Trennen angezeigt wird.If the state is Connected or Rendering, make sure the ProgressRing control is inactive and the disconnect button is visible.
  • Beim Zustand Disconnected heben Sie die Auswahl des aktuellen Umwandlungsgerät im Listenfeld auf, deaktivieren Sie das ProgressRing-Steuerelement, und blenden Sie die Schaltfläche zum Trennen aus.If the state is Disconnected, unselect the current casting device in the list box, make the ProgressRing control inactive, and hide the disconnect button.
  • Beim Zustand Connecting aktivieren Sie das ProgressRing-Steuerelement, und blenden Sie die Schaltfläche zum Trennen aus.If the state is Connecting, make the ProgressRing control active and hide the disconnect button.
  • Beim Zustand Disconnecting aktivieren Sie das ProgressRing-Steuerelement, und blenden Sie die Schaltfläche zum Trennen aus.If the state is Disconnecting, make the ProgressRing control active and hide the disconnect button.
private async void Connection_StateChanged(CastingConnection sender, object args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        //Update the UX based on the casting state
        if (sender.State == CastingConnectionState.Connected || sender.State == CastingConnectionState.Rendering)
        {
            disconnectButton.Visibility = Visibility.Visible;
            watcherProgressRing.IsActive = false;
        }
        else if (sender.State == CastingConnectionState.Disconnected)
        {
            disconnectButton.Visibility = Visibility.Collapsed;
            castingDevicesListBox.SelectedItem = null;
            watcherProgressRing.IsActive = false;
        }
        else if (sender.State == CastingConnectionState.Connecting)
        {
            disconnectButton.Visibility = Visibility.Collapsed;
            ShowMessageToUser("Connecting");
            watcherProgressRing.IsActive = true;
        }
        else
        {
            //Disconnecting is the remaining state
            disconnectButton.Visibility = Visibility.Collapsed;
            watcherProgressRing.IsActive = true;
        }
    });
}

Aktualisieren Sie im Handler für das ErrorOccurred-Ereignis die Benutzeroberfläche, um den Benutzer darüber zu informieren, dass ein Umwandlungsfehler aufgetreten ist, und heben Sie die Auswahl des aktuellen CastingDevice-Objekts im Listenfeld auf.In the handler for the ErrorOccurred event, update your UI to let the user know that a casting error occurred and unselect the current CastingDevice object in the list box.

private async void Connection_ErrorOccurred(CastingConnection sender, CastingConnectionErrorOccurredEventArgs args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        //Clear the selection in the listbox on an error
        ShowMessageToUser("Casting Error: " + args.Message);
        castingDevicesListBox.SelectedItem = null;
    });
}

Implementieren Sie zum Schluss den Handler für die Schaltfläche zum Trennen.Finally, implement the handler for the disconnect button. Beenden Sie die Medienumwandlung, und trennen Sie die Verbindung mit dem Umwandlungsgerät, indem Sie die DisconnectAsync-Methode des CastingConnection-Objekts aufrufen.Stop media casting and disconnect from the casting device by calling the CastingConnection object's DisconnectAsync method. Dieser Aufruf muss durch Aufrufen von CoreDispatcher.RunAsync an den UI-Thread weitergeleitet werden.This call must be dispatched to the UI thread by calling CoreDispatcher.RunAsync.

private async void disconnectButton_Click(object sender, RoutedEventArgs e)
{
    if (castingConnection != null)
    {
        //When disconnect is clicked, the casting conneciton is disconnected.  The video should return locally to the media element.
        await castingConnection.DisconnectAsync();
    }
}