Erstellen, Planen und Verwalten von Medienunterbrechungen

  • Artikel

In diesem Artikel wird beschrieben, wie Sie für Ihre App zur Medienwiedergabe Medienunterbrechungen erstellen, planen und verwalten. Medienunterbrechungen werden normalerweise genutzt, um Audio- und Videoanzeigen in Medieninhalte einzufügen. Ab Windows 10, Version 1607, können Sie die MediaBreakManager-Klasse verwenden, um schnell und einfach Medienunterbrechungen zu jedem MediaPlaybackItem-Element hinzuzufügen, das Sie mit einem MediaPlayer abspielen.

Nachdem Sie eine oder mehrere Medienunterbrechungen geplant haben, spielt das System automatisch die Medieninhalte zum angegebenen Zeitpunkt während der Wiedergabe ab. Der MediaBreakManager stellt Ereignisse bereit, damit Ihre App reagieren kann, wenn Medienunterbrechungen beginnen, enden oder vom Benutzer übersprungen werden. Sie können auch auf eine MediaPlaybackSession für Ihre Medienunterbrechnungen zugreifen, um Ereignisse, wie z. B. das Herunterladen und Puffern von Updates, zu überwachen.

Medienunterbrechungen planen

Jedes MediaPlaybackItem-Objekt verfügt über einen eigenen MediaBreakSchedule zum Konfigurieren der Medienunterbrechungen, die wiedergegeben werden sollen, wenn das Element abgespielt wird. Der erste Schritt zur Verwendung von Medienunterbrechungen in Ihrer App ist die Erstellung eines MediaPlaybackItem-Elements für Ihre Hauptinhalte für die Wiedergabe.

MediaPlaybackItem moviePlaybackItem =
    new MediaPlaybackItem(MediaSource.CreateFromUri(new Uri("http://www.fabrikam.com/movie.mkv")));

Weitere Informationen zum Arbeiten mit MediaPlaybackItem, MediaPlaybackList und anderen grundlegenden Medienwiedergabe-APIs finden Sie unter Medienelemente, Wiedergabelisten und Titel.

Das nächste Beispiel zeigt, wie Sie dem MediaPlaybackItem-Element eine PreRoll-Unterbrechung hinzufügen, was bedeutet, dass das System die Medienunterbrechung vor der Wiedergabe des Wiedergabeelements, zu dem die Unterbrechung gehört, wiedergibt. Zuerst wird ein neues MediaBreak-Objekt instanziiert. In diesem Beispiel wird der Konstruktor mit MediaBreakInsertionMethod.Interrupt aufgerufen, d. h. der Hauptinhalt wird angehalten, während der Unterbrechungsinhalt wiedergegeben wird.

Als Nächstes wird ein neues MediaPlaybackItem-Element für den Inhalt erstellt, der während der Unterbrechung, z. B. in Form einer Anzeige, wiedergegeben wird. Die CanSkip-Eigenschaft dieses Wiedergabeelements ist auf "false" festgelegt. Das bedeutet, dass der Benutzer das Element mit den integrierten Mediensteuerelementen nicht überspringen kann. Die App kann dennoch entscheiden, die Anzeige durch den Aufruf von SkipCurrentBreak programmgesteuert zu überspringen.

Die PlaybackList-Eigenschaft der Medienunterbrechung ist eine MediaPlaybackList, mit der Sie mehrere Medienelemente als eine Wiedergabeliste wiedergegeben können. Fügen Sie ein oder mehrere MediaPlaybackItem-Objekte aus der Sammlung Elemente der Liste hinzu, um sie in die Wiedergabeliste der Medienunterbrechung einzufügen.

Planen Sie dann die Medienunterbrechung, indem Sie die BreakSchedule-Eigenschaft des Elements für die Wiedergabe des Hauptinhalts. Definieren Sie die Unterbrechung als PreRoll-Unterbrechung, indem Sie sie der PrerollBreak-Eigenschaft des Schedule-Objekts zuweisen.

MediaBreak preRollMediaBreak = new MediaBreak(MediaBreakInsertionMethod.Interrupt);
MediaPlaybackItem prerollAd = 
    new MediaPlaybackItem(MediaSource.CreateFromUri(new Uri("http://www.fabrikam.com/preroll_ad.mp4")));
prerollAd.CanSkip = false;
preRollMediaBreak.PlaybackList.Items.Add(prerollAd);

moviePlaybackItem.BreakSchedule.PrerollBreak = preRollMediaBreak;

Jetzt können Sie das Hauptmedienelement wiedergeben, wobei die von Ihnen erstellte Medienunterbrechung vor dem Hauptinhalt wiedergegeben wird. Erstellen Sie ein neues MediaPlayer-Objekt, und legen Sie die AutoPlay-Eigenschaft optional auf "true" fest, um die Wiedergabe automatisch zu starten. Legen Sie die Source-Eigenschaft des MediaPlayer auf das Element für die Wiedergabe des Hauptinhalts fest. Es ist zwar nicht erforderlich, aber Sie können den MediaPlayer einem MediaPlayerElement zuweisen, um die Medien auf einer XAML-Seite zu rendern. Weitere Informationen zur Verwendung des MediaPlayer finden Sie unter Wiedergeben von Audio- und Videoinhalten mit MediaPlayer.

_mediaPlayer = new MediaPlayer();
_mediaPlayer.AutoPlay = true;
_mediaPlayer.Source = moviePlaybackItem;
mediaPlayerElement.SetMediaPlayer(_mediaPlayer);

Fügen Sie eine PostRoll-Unterbrechung hinzu, die nach Abschluss der Wiedergabe des MediaPlaybackItem, das den Hauptinhalt enthält, wiedergegeben wird. Verwenden Sie dabei das gleiche Verfahren wie bei einer PreRoll-Unterbrechung, außer dass Sie Ihr MediaBreak-Objekt der PostrollBreak-Eigenschaft zuweisen.

MediaBreak postrollMediaBreak = new MediaBreak(MediaBreakInsertionMethod.Interrupt);
MediaPlaybackItem postRollAd =
    new MediaPlaybackItem(MediaSource.CreateFromUri(new Uri("http://www.fabrikam.com/postroll_ad.mp4")));
postrollMediaBreak.PlaybackList.Items.Add(postRollAd);

moviePlaybackItem.BreakSchedule.PostrollBreak = postrollMediaBreak;

Sie können auch eine oder mehrere MidRoll-Unterbrechungen planen, die zur angegebenen Zeit innerhalb der Wiedergabe des Hauptinhalts wiedergegeben werden. Im folgenden Beispiel wird das MediaBreak-Objekt mit der Konstruktorüberladung erstellt, die ein TimeSpan-Objekt akzeptiert, das innerhalb der Wiedergabe des Hauptmedienelements die Zeit für die Wiedergabe der Unterbrechung angibt. Auch hier wird ein MediaBreakInsertionMethod.Interrupt festgelegt, um anzugeben, dass die Wiedergabe des Hauptinhalts während der Wiedergabe der Unterbrechung angehalten wird. Die MidRoll-Unterbrechung wird dem Zeitplan durch Aufrufen von InsertMidrollBreak hinzugefügt. Sie können eine schreibgeschützte Liste der aktuellen MidRoll-Unterbrechungen im Zeitplan abrufen, indem Sie auf die MidrollBreaks-Eigenschaft zugreifen.

MediaBreak midrollMediaBreak = new MediaBreak(MediaBreakInsertionMethod.Interrupt, TimeSpan.FromMinutes(10));
midrollMediaBreak.PlaybackList.Items.Add(
    new MediaPlaybackItem(MediaSource.CreateFromUri(new Uri("http://www.fabrikam.com/midroll_ad_1.mp4"))));
midrollMediaBreak.PlaybackList.Items.Add(
    new MediaPlaybackItem(MediaSource.CreateFromUri(new Uri("http://www.fabrikam.com/midroll_ad_2.mp4"))));
moviePlaybackItem.BreakSchedule.InsertMidrollBreak(midrollMediaBreak);

Beim nächsten Beispiel für eine MidRoll-Unterbrechung wird die MediaBreakInsertionMethod.Replace-Einfügemethode verwendet. Dies bedeutet, dass das System während der Wiedergabe der Unterbrechung die Verarbeitung des Hauptinhalts fortsetzt. Diese Option wird normalerweise von Live-Streaming-Medien-Apps verwendet, deren Inhalt nicht angehalten und hinter den Live-Stream zurückfallen soll, während die Anzeige wiedergegeben wird.

Bei diesem Beispiel wird auch eine Überladung des MediaPlaybackItem-Konstruktors verwendet, der zwei TimeSpan-Parameter akzeptiert. Der erste Parameter definiert den Startpunkt innerhalb des Medienunterbrechungselements, an dem die Wiedergabe beginnen soll. Der zweite Parameter definiert die Dauer, während der die Medienunterbrechung wiedergegeben werden soll. Im folgenden Beispiel beginnt daher die MediaBreak-Wiedergabe bei 20 Minuten im Hauptinhalt. Mit seiner Wiedergabe beginnt das Medienelement 30 Sekunden ab dem Beginn des Unterbrechungsmedienelements und setzt sie 15 Sekunden lang fort, bevor die Wiedergabe des Hauptmedieninhalts wieder aufgenommen wird.

midrollMediaBreak = new MediaBreak(MediaBreakInsertionMethod.Replace, TimeSpan.FromMinutes(20));
MediaPlaybackItem ad = 
    new MediaPlaybackItem(MediaSource.CreateFromUri(new Uri("http://www.fabrikam.com/midroll_ad_3.mp4")),
    TimeSpan.FromSeconds(30),
    TimeSpan.FromSeconds(15));
ad.CanSkip = false;
midrollMediaBreak.PlaybackList.Items.Add(ad);

Medienunterbrechungen überspringen

Wie bereits in diesem Artikel erwähnt, kann die CanSkip-Eigenschaft eines MediaPlaybackItem so festgelegt werden, dass der Benutzer den Inhalt mit den integrierten Steuerelementen nicht überspringen kann. Sie können jedoch SkipCurrentBreak im Code jederzeit aufrufen, um die aktuelle Unterbrechung zu überspringen.

private void SkipButton_Click(object sender, RoutedEventArgs e) => _mediaPlayer.BreakManager.SkipCurrentBreak();

Behandeln von MediaBreak-Ereignissen

Es gibt verschiedene Ereignisse im Zusammenhang mit Medienunterbrechungen, für die Sie sich registrieren können, um basierend auf den Zustandsänderungen von Medienunterbrechungen Maßnahmen zu ergreifen.

_mediaPlayer.BreakManager.BreakStarted += BreakManager_BreakStarted;
_mediaPlayer.BreakManager.BreakEnded += BreakManager_BreakEnded;
_mediaPlayer.BreakManager.BreakSkipped += BreakManager_BreakSkipped;
_mediaPlayer.BreakManager.BreaksSeekedOver += BreakManager_BreaksSeekedOver;

Das BreakStarted-Ereignis wird ausgelöst, wenn eine Medienunterbrechung beginnt. Es empfiehlt sich, die Benutzeroberfläche zu aktualisieren, um den Benutzer darauf hinzuweisen, dass Unterbrechungsmedieninhalt wiedergegeben wird. In diesem Beispiel wird das dem Handler übergebene MediaBreakStartedEventArgs-Objekt verwendet, um einen Verweis auf die Medienunterbrechung zu erhalten, die begonnen hat. Anschließend wird die CurrentItemIndex-Eigenschaft verwendet, um zu bestimmen, welches Medienelement in der Wiedergabeliste der Medienunterbrechung wiedergegeben wird. Dann wird die Benutzeroberfläche aktualisiert, um dem Benutzer den aktuellen Anzeigenindex und die Anzahl der in der Unterbrechung verbliebenen Anzeigen anzuzeigen. Beachten Sie, dass Aktualisierungen der Benutzeroberfläche im UI-Thread vorgenommen werden müssen. Daher sollte der Aufruf innerhalb eines Aufrufs von RunAsync erfolgen.

private async void BreakManager_BreakStarted(MediaBreakManager sender, MediaBreakStartedEventArgs args)
{
    MediaBreak currentBreak = sender.CurrentBreak;
    var currentIndex = currentBreak.PlaybackList.CurrentItemIndex;
    var itemCount = currentBreak.PlaybackList.Items.Count;

    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>            
        statusTextBlock.Text = $"Playing ad {currentIndex + 1} of {itemCount}");
}

BreakEnded wird ausgelöst, wenn alle Medienelemente in der Unterbrechung wiedergegeben oder übersprungen wurden. Sie können den Handler für dieses Ereignis zum Aktualisieren der Benutzeroberfläche verwenden, um anzugeben, dass die Wiedergabe der Medienunterbrechung beendet ist.

private async void BreakManager_BreakEnded(MediaBreakManager sender, MediaBreakEndedEventArgs args)
{
    // Update UI to show that the MediaBreak is no longer playing
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => statusTextBlock.Text = "");

    args.MediaBreak.CanStart = false;
}

Das BreakSkipped-Ereignis wird ausgelöst, wenn der Benutzer in der integrierten Benutzeroberfläche die Schaltfläche Weiter während der Wiedergabe eines Elements drückt, für das CanSkip den Wert true hat, oder wenn Sie eine Unterbrechung in Ihrem Code durch Aufrufen von SkipCurrentBreak überspringen.

Im folgenden Beispiel wird die Source-Eigenschaft des MediaPlayer verwendet, um einen Verweis auf das Medienelement für den Hauptinhalt zu erhalten. Die übersprungene Medienunterbrechung gehört zum Unterbrechungszeitplan dieses Elements. Als Nächstes führt der Code eine Überprüfung durch, um festzustellen, ob die übersprungene Medienunterbrechung der Medienunterbrechung entspricht, für die die PrerollBreak-Eigenschaft des Zeitplans festgelegt wurde. Falls ja, bedeutet dies, dass es sich bei der PreRoll-Unterbrechung um die übersprungene Unterbrechung handelt, und in diesem Fall eine neue MidRoll-Unterbrechung erstellt und für die Wiedergabe von 10 Minuten in den Hauptinhalt geplant wird.

private async void BreakManager_BreakSkipped(MediaBreakManager sender, MediaBreakSkippedEventArgs args)
{
    // Update UI to show that the MediaBreak is no longer playing
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => statusTextBlock.Text = "");

    MediaPlaybackItem currentItem = _mediaPlayer.Source as MediaPlaybackItem;
    if(!(currentItem.BreakSchedule.PrerollBreak is  null) 
        && currentItem.BreakSchedule.PrerollBreak == args.MediaBreak)
    {
        MediaBreak mediaBreak = new MediaBreak(MediaBreakInsertionMethod.Interrupt, TimeSpan.FromMinutes(10));
        mediaBreak.PlaybackList.Items.Add(await GetAdPlaybackItem());
        currentItem.BreakSchedule.InsertMidrollBreak(mediaBreak);
    }
}

BreaksSeekedOver wird ausgelöst, wenn die Wiedergabeposition des Hauptmedienelements den geplanten Zeitpunkt für eine oder mehrere Medienunterbrechungen passiert. Im folgenden Beispiel wird eine Überprüfung durchgeführt, um festzustellen, ob mehr als eine Medienunterbrechung übergangen wurde, wenn die Wiedergabeposition nach vorne verschoben wird und wenn sie um weniger als 10 Minuten nach vorne verschoben wird. Falls ja, wird die erste übergangene Unterbrechung, die aus der SeekedOverBreaks-Sammlung abgerufen und von den Ereignisargumenten verfügbar gemacht wurde, durch einen Aufruf der PlayBreak-Methode des MediaPlayer.BreakManager sofort wiedergegeben.

private void BreakManager_BreaksSeekedOver(MediaBreakManager sender, MediaBreakSeekedOverEventArgs args)
{
    if(args.SeekedOverBreaks.Count > 1
        && args.NewPosition.TotalMinutes > args.OldPosition.TotalMinutes
        && args.NewPosition.TotalMinutes - args.OldPosition.TotalMinutes < 10.0)
        _mediaPlayer.BreakManager.PlayBreak(args.SeekedOverBreaks[0]);
}

Zugreifen auf die aktuelle Wiedergabesitzung

Das MediaPlaybackSession-Objekt verwendet die MediaPlayer-Klasse, um Daten und Ereignisse in Zusammenhang mit den gerade wiedergegebenen Medieninhalten bereitzustellen. Der MediaBreakManager verfügt auch über eine MediaPlaybackSession, auf die Sie zugreifen können, um Daten und Ereignisse abzurufen, die sich speziell auf den Inhalt der Medienunterbrechung beziehen, der gerade wiedergegeben wird. Zu den Informationen, die Sie aus der Wiedergabesitzung erhalten können, gehören der aktuelle Wiedergabestatus, Wiedergabe oder Angehalten, und die aktuelle Wiedergabeposition innerhalb des Inhalts. Sie können die Eigenschaften NaturalVideoWidth und NaturalVideoHeight sowie NaturalVideoSizeChanged verwenden, um die Video-Benutzeroberfläche anzupassen, wenn der Inhalt der Medienunterbrechung ein anderes Seitenverhältnis besitzt als der Hauptinhalt. Sie können auch Ereignisse empfangen, wie z. B. BufferingStarted, BufferingEnded und DownloadProgressChanged, die wertvolle Telemetriedaten zur Leistung Ihrer App liefern können.

Im folgenden Beispiel wird ein Handler für das BufferingProgressChanged-Ereignis registriert. Im Ereignishandler aktualisiert es die Benutzeroberfläche, um den aktuellen Fortschritt der Pufferung anzuzeigen.

_mediaPlayer.BreakManager.PlaybackSession.BufferingProgressChanged += PlaybackSession_BufferingProgressChanged;

private async void PlaybackSession_BufferingProgressChanged(MediaPlaybackSession sender, object args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        bufferingProgressBar.Value = sender.BufferingProgress);
}