Manuelle Steuerung der Steuerelemente für den Systemmedientransport

Ab Windows 10, Version 1607, werden UWP-Apps, die die MediaPlayer-Klasse zum Wiedergeben von Medien verwenden, standardmäßig automatisch in die Steuerelemente für den Systemmedientransport (System Media Transport Controls, SMTC) integriert. Dies ist die empfohlene Methode für die Interaktion mit smTC für die meisten Szenarien. Weitere Informationen zum Anpassen der Standardintegration von SMTC in MediaPlayer finden Sie unter Integration in die Steuerelemente für den Systemmedientransport.

Es gibt einige Szenarien, in denen Sie möglicherweise die manuelle Steuerung des SMTC implementieren müssen. Dazu gehören, wenn Sie einen MediaTimelineController verwenden, um die Wiedergabe eines oder mehrerer Media Player zu steuern. Oder wenn Sie mehrere Media Player verwenden und nur eine Instanz von SMTC für Ihre App verwenden möchten. Sie müssen die SMTC manuell steuern, wenn Sie MediaElement zum Wiedergeben von Medien verwenden.

Einrichten von Transportsteuerelementen

Wenn Sie MediaPlayer zum Wiedergeben von Medien verwenden, können Sie eine Instanz der SystemMediaTransportControls-Klasse abrufen, indem Sie auf die MediaPlayer.SystemMediaTransportControls-Eigenschaft zugreifen. Wenn Sie die SMTC manuell steuern möchten, sollten Sie die von MediaPlayer bereitgestellte automatische Integration deaktivieren, indem Sie die CommandManager.IsEnabled-Eigenschaft auf "false" festlegen.

_mediaPlayer = new MediaPlayer();
_systemMediaTransportControls = _mediaPlayer.SystemMediaTransportControls;
_mediaPlayer.CommandManager.IsEnabled = false;

Sie können auch eine Instanz von SystemMediaTransportControls abrufen, indem Sie GetForCurrentView aufrufen. Sie müssen das Objekt mit dieser Methode abrufen, wenn Sie MediaElement zum Wiedergeben von Medien verwenden.

_systemMediaTransportControls = SystemMediaTransportControls.GetForCurrentView();

Aktivieren Sie die Schaltflächen, die Ihre App verwenden wird, indem Sie die entsprechende "is enabled"-Eigenschaft des SystemMediaTransportControls-Objekts festlegen, z. B. IsPlayEnabled, IsPauseEnabled, IsNextEnabled und IsPreviousEnabled. Eine vollständige Liste der verfügbaren Steuerelemente finden Sie in der Referenzdokumentation zu SystemMediaTransportControls .

_systemMediaTransportControls.IsPlayEnabled = true;
_systemMediaTransportControls.IsPauseEnabled = true;

Registrieren Sie einen Handler für das ButtonPressed-Ereignis , um Benachrichtigungen zu empfangen, wenn der Benutzer eine Schaltfläche drückt.

_systemMediaTransportControls.ButtonPressed += SystemControls_ButtonPressed;

Behandeln der Steuerelemente für den Systemmedientransport

Das ButtonPressed-Ereignis wird von den Systemtransportsteuerelementen ausgelöst, wenn eine der aktivierten Schaltflächen gedrückt wird. Die Button-Eigenschaft der an den Ereignishandler übergebenen SystemMediaTransportControlsButtonPressedEventArgs ist ein Element der SystemMediaTransportControlsButton-Aufzählung, die angibt, welche der aktivierten Schaltflächen gedrückt wurde.

Um Objekte im UI-Thread über den ButtonPressed-Ereignishandler zu aktualisieren, z. B. ein MediaElement-Objekt, müssen Sie die Aufrufe über den CoreDispatcher marshallen. Dies liegt daran, dass der ButtonPressed-Ereignishandler nicht aus dem UI-Thread aufgerufen wird und daher eine Ausnahme ausgelöst wird, wenn Sie versuchen, die Benutzeroberfläche direkt zu ändern.

async void SystemControls_ButtonPressed(SystemMediaTransportControls sender,
    SystemMediaTransportControlsButtonPressedEventArgs args)
{
    switch (args.Button)
    {
        case SystemMediaTransportControlsButton.Play:
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                mediaElement.Play();
            });
            break;
        case SystemMediaTransportControlsButton.Pause:
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                mediaElement.Pause();
            });
            break;
        default:
            break;
    }
}

Aktualisieren der Steuerelemente für den Systemmedientransport mit dem aktuellen Medienstatus

Sie sollten systemMediaTransportControls benachrichtigen, wenn sich der Zustand der Medien geändert hat, damit das System die Steuerelemente aktualisieren kann, um den aktuellen Zustand widerzuspiegeln. Legen Sie dazu die PlaybackStatus-Eigenschaft auf den entsprechenden MediaPlaybackStatus-Wert innerhalb des CurrentStateChanged-Ereignisses des MediaElements fest, das ausgelöst wird, wenn sich der Medienstatus ändert.

void MediaElement_CurrentStateChanged(object sender, RoutedEventArgs e)
{
    switch (mediaElement.CurrentState)
    {
        case MediaElementState.Playing:
            _systemMediaTransportControls.PlaybackStatus = MediaPlaybackStatus.Playing;
            break;
        case MediaElementState.Paused:
            _systemMediaTransportControls.PlaybackStatus = MediaPlaybackStatus.Paused;
            break;
        case MediaElementState.Stopped:
            _systemMediaTransportControls.PlaybackStatus = MediaPlaybackStatus.Stopped;
            break;
        case MediaElementState.Closed:
            _systemMediaTransportControls.PlaybackStatus = MediaPlaybackStatus.Closed;
            break;
        default:
            break;
    }
}

Aktualisieren der Steuerelemente für den Systemmedientransport mit Medieninformationen und Miniaturansichten

Verwenden Sie die SystemMediaTransportControlsDisplayUpdater-Klasse , um die Medieninformationen zu aktualisieren, die von den Transportsteuerelementen angezeigt werden, z. B. den Songtitel oder das Albumcover für das aktuell wiedergegebene Medienelement. Rufen Sie eine Instanz dieser Klasse mit der SystemMediaTransportControls.DisplayUpdater-Eigenschaft ab. Für typische Szenarien empfiehlt es sich, die Metadaten zu übergeben, "CopyFromFileAsync" aufzurufen und dabei die aktuell wiedergegebene Mediendatei zu übergeben. Der Anzeigeupdater extrahiert automatisch die Metadaten und das Miniaturbild aus der Datei.

Rufen Sie das Update auf, damit die Steuerelemente für den Systemmedientransport ihre Benutzeroberfläche mit den neuen Metadaten und Miniaturansichten aktualisieren.

async void MediaElement_MediaOpened(object sender, RoutedEventArgs e)
{
    // Get the updater.
    SystemMediaTransportControlsDisplayUpdater updater = _systemMediaTransportControls.DisplayUpdater;

    await updater.CopyFromFileAsync(MediaPlaybackType.Music, currentMediaFile);

    // Update the system media transport controls
    updater.Update();
}

Wenn Ihr Szenario dies erfordert, können Sie die von den Steuerelementen für den Systemmedientransport angezeigten Metadaten manuell aktualisieren, indem Sie die Werte der Von der DisplayUpdater-Klasse verfügbar gemachten Objekte "MusicProperties", "ImageProperties" oder "VideoProperties" festlegen.

// Get the updater.
SystemMediaTransportControlsDisplayUpdater updater = _systemMediaTransportControls.DisplayUpdater;

// Music metadata.
updater.Type = MediaPlaybackType.Music;
updater.MusicProperties.Artist = "artist";
updater.MusicProperties.AlbumArtist = "album artist";
updater.MusicProperties.Title = "song title";

// Set the album art thumbnail.
// RandomAccessStreamReference is defined in Windows.Storage.Streams
updater.Thumbnail =
   RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Music/music1_AlbumArt.jpg"));

// Update the system media transport controls.
updater.Update();

Aktualisieren der Zeitachseneigenschaften des Systemmedientransportsteuerelements

Die Steuerelemente für den Systemtransport zeigen Informationen zur Zeitachse des aktuell wiedergegebenen Medienelements an, einschließlich der aktuellen Wiedergabeposition, der Startzeit und der Endzeit des Medienelements. Um die Zeitachseneigenschaften des Systemtransportsteuerelements zu aktualisieren, erstellen Sie ein neues SystemMediaTransportControlsTimelineProperties-Objekt. Legen Sie die Eigenschaften des Objekts fest, um den aktuellen Zustand des wiedergegebenen Medienelements widerzuspiegeln. Rufen Sie SystemMediaTransportControls.UpdateTimelineProperties auf, damit die Steuerelemente die Zeitachse aktualisieren.

// Create our timeline properties object 
var timelineProperties = new SystemMediaTransportControlsTimelineProperties();

// Fill in the data, using the media elements properties 
timelineProperties.StartTime = TimeSpan.FromSeconds(0);
timelineProperties.MinSeekTime = TimeSpan.FromSeconds(0);
timelineProperties.Position = mediaElement.Position;
timelineProperties.MaxSeekTime = mediaElement.NaturalDuration.TimeSpan;
timelineProperties.EndTime = mediaElement.NaturalDuration.TimeSpan;

// Update the System Media transport Controls 
_systemMediaTransportControls.UpdateTimelineProperties(timelineProperties);

• Sie müssen einen Wert für startTime, EndTime und Position angeben, damit die Systemsteuerelemente eine Zeitachse für Ihr Wiedergabeelement anzeigen können.

• Mit MinSeekTime und MaxSeekTime können Sie den Bereich innerhalb der Zeitachse angeben, die der Benutzer suchen kann. Ein typisches Szenario hierfür besteht darin, Inhaltsanbietern die Aufnahme von Werbeunterbrechungen in ihre Medien zu ermöglichen.

  Sie müssen "MinSeekTime" und "MaxSeekTime" festlegen, damit die PositionChangeRequest ausgelöst wird.

• Es wird empfohlen, die Systemsteuerelemente mit der Medienwiedergabe synchron zu halten, indem Sie diese Eigenschaften ungefähr alle 5 Sekunden während der Wiedergabe und wieder aktualisieren, wenn sich der Zustand der Wiedergabe ändert, z. B. anhalten oder eine neue Position suchen.

Reagieren auf Änderungen der Spielereigenschaft

Es gibt eine Reihe von Eigenschaften des Systemtransportsteuerelements, die sich auf den aktuellen Zustand des Media Players selbst beziehen, anstatt den Zustand des wiedergegebenen Medienelements. Jede dieser Eigenschaften wird mit einem Ereignis abgeglichen, das ausgelöst wird, wenn der Benutzer das zugeordnete Steuerelement anpasst. Zu diesen Eigenschaften und Ereignissen gehören:

  Um die Benutzerinteraktion mit einem dieser Steuerelemente zu behandeln, registrieren Sie zuerst einen Handler für das zugeordnete Ereignis.

_systemMediaTransportControls.PlaybackRateChangeRequested += SystemControls_PlaybackRateChangeRequested;

Stellen Sie zunächst im Handler für das Ereignis sicher, dass sich der angeforderte Wert innerhalb eines gültigen und erwarteten Bereichs befindet. Wenn dies der Grund ist, legen Sie die entsprechende Eigenschaft für MediaElement fest, und legen Sie dann die entsprechende Eigenschaft für das SystemMediaTransportControls -Objekt fest.

void SystemControls_PlaybackRateChangeRequested(SystemMediaTransportControls sender, PlaybackRateChangeRequestedEventArgs args)
{
    // Check the requested value to make sure it is within a valid and expected range
    if (args.RequestedPlaybackRate >= 0 && args.RequestedPlaybackRate <= 2)
    {
        // Set the requested value on the MediaElement
        mediaElement.PlaybackRate = args.RequestedPlaybackRate;

        // Update the system media controls to reflect the new value
        _systemMediaTransportControls.PlaybackRate = mediaElement.PlaybackRate;
    }
}

• Damit eines dieser Spielereigenschaftsereignisse ausgelöst werden kann, müssen Sie einen Anfangswert für die Eigenschaft festlegen. Beispielsweise wird "PlaybackRateChangeRequested" erst ausgelöst, nachdem Sie mindestens ein Mal einen Wert für die PlaybackRate-Eigenschaft festgelegt haben.

Verwenden der Steuerelemente für den Systemmedientransport für Hintergrundaudio

Wenn Sie die von MediaPlayer bereitgestellte automatische SMTC-Integration nicht verwenden, müssen Sie manuell in smTC integriert werden, um Hintergrundaudio zu aktivieren. Ihre App muss mindestens die Wiedergabe- und Pausenschaltflächen aktivieren, indem Sie "IsPlayEnabled" und "IsPauseEnabled" auf "true" festlegen. Ihre App muss auch das ButtonPressed-Ereignis behandeln. Wenn Ihre App diese Anforderungen nicht erfüllt, wird die Audiowiedergabe beendet, wenn Ihre App in den Hintergrund wechselt.

Apps, die das neue Einprozessmodell für Hintergrundaudio verwenden, sollten eine Instanz von SystemMediaTransportControls abrufen, indem Sie GetForCurrentView aufrufen. Apps, die das ältere Modell mit zwei Prozessen für Hintergrundaudio verwenden, müssen BackgroundMediaPlayer.Current.SystemMediaTransportControls verwenden, um über ihren Hintergrundprozess Zugriff auf smTC zu erhalten.

Weitere Informationen zum Wiedergeben von Audio im Hintergrund finden Sie unter "Wiedergeben von Medien im Hintergrund".

Zugehörige Themen

• Medienwiedergabe
• Integration in die Steuerelemente für den Systemmedientransport 
• Beispiel für den Systemmedientransport