Éléments, playlists et pistes multimédiasMedia items, playlists, and tracks

Cet article explique comment utiliser la classe MediaSource , qui permet de référencer et de lire des médias de différentes sources, tels que des fichiers locaux ou distants, et d’exposer un modèle commun pour l’accès aux données multimédias, quel que soit le format de média sous-jacent.This article shows you how to use the MediaSource class, which provides a common way to reference and play back media from different sources such as local or remote files and exposes a common model for accessing media data, regardless of the underlying media format. La classe MediaPlaybackItem étend les fonctionnalités de MediaSource, vous permettant ainsi de gérer et de sélectionner à partir de plusieurs pistes audio, vidéo et de métadonnées contenues dans un élément multimédia.The MediaPlaybackItem class extends the functionality of MediaSource, allowing you to manage and select from multiple audio, video, and metadata tracks contained in a media item. MediaPlaybackList vous permet de créer des listes de lecture à partir d’un ou de plusieurs éléments de lecture multimédia.MediaPlaybackList allows you to create playback lists from one or more media playback items.

Créer et lire un MediaSourceCreate and play a MediaSource

Créez une instance de MediaSource en appelant l’une des méthodes de fabrique exposées par la classe :Create a new instance of MediaSource by calling one of the factory methods exposed by the class:

Après avoir créé un MediaSource, vous pouvez le lire avec un MediaPlayer en définissant la propriété Source.After creating a MediaSource you can play it with a MediaPlayer by setting the Source property. À compter de Windows 10, version 1607, vous pouvez attribuer un MediaPlayer à un MediaPlayerElement en appelant SetMediaPlayer pour afficher le contenu du lecteur multimédia dans une page XAML.Starting with Windows 10, version 1607, you can assign a MediaPlayer to a MediaPlayerElement by calling SetMediaPlayer in order to render the media player content in a XAML page. Cette méthode est préférée à l’utilisation de MediaElement.This is the preferred method over using MediaElement. Pour plus d’informations sur l’utilisation de MediaPlayer, voir Lire du contenu audio et vidéo avec MediaPlayer.For more information on using MediaPlayer, see Play audio and video with MediaPlayer.

L’exemple suivant montre comment lire un fichier multimédia sélectionné par l’utilisateur dans un MediaPlayer à l’aide de MediaSource.The following example shows how to play back a user-selected media file in a MediaPlayer using MediaSource.

Pour effectuer ce scénario, vous devez inclure les espaces de noms Windows. Media. Core et Windows. Media. playback .You will need to include the Windows.Media.Core and Windows.Media.Playback namespaces in order to complete this scenario.

using Windows.Media.Core;
using Windows.Media.Playback;

Déclarez une variable de type MediaSource.Declare a variable of type MediaSource. Pour les exemples de cet article, la source multimédia est déclarée en tant que membre de classe. Elle est donc accessible à partir de plusieurs emplacements.For the examples in this article, the media source is declared as a class member so that it can be accessed from multiple locations.

MediaSource _mediaSource;

Déclarez une variable pour stocker l’objet MediaPlayer et, si vous voulez afficher le contenu multimédia en XAML, ajoutez un contrôle MediaPlayerElement à votre page.Declare a variable to store the MediaPlayer object and, if you want to render the media content in XAML, add a MediaPlayerElement control to your page.

MediaPlayer _mediaPlayer;
<MediaPlayerElement x:Name="mediaPlayerElement"/>

Pour permettre à l’utilisateur de sélectionner un fichier multimédia à lire, utilisez un FileOpenPicker.To allow the user to pick a media file to play, use a FileOpenPicker. Avec l’objet StorageFile retourné par la méthode PickSingleFileAsync du sélecteur, initialisez un nouveau MediaObject en appelant MediaSource. CreateFromStorageFile.With the StorageFile object returned from the picker's PickSingleFileAsync method, initialize a new MediaObject by calling MediaSource.CreateFromStorageFile. Enfin, définissez la source du média en tant que source de lecture de MediaElement en appelant la méthode SetPlaybackSource.Finally, set the media source as the playback source for the MediaElement by calling the SetPlaybackSource method.

//Create a new picker
var filePicker = new Windows.Storage.Pickers.FileOpenPicker();

//make a collection of all video types you want to support (for testing we are adding just 3).
string[] fileTypes = new string[] {".wmv", ".mp4", ".mkv"};   
   
//Add your fileTypes to the FileTypeFilter list of filePicker.
foreach (string fileType in fileTypes)
{
    filePicker.FileTypeFilter.Add(fileType);
}

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

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

if (!(file is null))
{
    _mediaSource = MediaSource.CreateFromStorageFile(file);
    _mediaPlayer = new MediaPlayer();
    _mediaPlayer.Source = _mediaSource;
    mediaPlayerElement.SetMediaPlayer(_mediaPlayer);
}

Par défaut, le MediaPlayer ne commence pas automatiquement la lecture quand la source du média est définie.By default, the MediaPlayer does not begin playing automatically when the media source is set. Vous pouvez commencer la lecture manuellement en appelant Play.You can manually begin playback by calling Play.

_mediaPlayer.Play();

Vous pouvez également définir la propriété AutoPlay de MediaPlayer sur true pour indiquer au lecteur de commencer la lecture dès que la source du média est définie.You can also set the AutoPlay property of the MediaPlayer to true to tell the player to begin playing as soon as the media source is set.

_mediaPlayer.AutoPlay = true;

Créer un MediaSource à partir d’un DownloadOperationCreate a MediaSource from a DownloadOperation

À compter de Windows, version 1803, vous pouvez créer un objet MediaSource à partir d’un DownloadOperation.Starting with Windows, version 1803, you can create a MediaSource object from a DownloadOperation.

StorageFile destinationFile = await KnownFolders.VideosLibrary.CreateFileAsync("file.mp4", CreationCollisionOption.GenerateUniqueName);

var downloader = new BackgroundDownloader();
var downloadOperation = downloader.CreateDownload(new Uri("http://server.com/file.mp4"), destinationFile);
MediaSource mediaSource =
      MediaSource.CreateFromDownloadOperation(downloadOperation);

Notez que, bien que vous puissiez créer un MediaSource à partir d’un téléchargement sans le démarrer ou définir sa propriété IsRandomAccessRequired sur true, vous devez effectuer ces deux opérations avant de tenter d’attacher le MediaSource à un MediaPlayer ou à un MediaPlayerElement pour la lecture.Note that while you can create a MediaSource from a download without starting it or setting its IsRandomAccessRequired property to true, you must do both of these things before attempting to attach the MediaSource to a MediaPlayer or MediaPlayerElement for playback.

downloadOperation.IsRandomAccessRequired = true;
var startAsyncTask = downloadOperation.StartAsync().AsTask();
mediaPlayerElement.Source = mediaSource;

Gérer plusieurs pistes audio, vidéo et de métadonnées avec MediaPlaybackItemHandle multiple audio, video, and metadata tracks with MediaPlaybackItem

L’utilisation d’un objet MediaSource pour la lecture est pratique car il offre une méthode courante de lecture multimédia à partir de différents types de sources. Un comportement plus avancé est toutefois disponible en créant un MediaPlaybackItem à partir de MediaSource.Using a MediaSource for playback is convenient because it provides a common way to playback media from different kinds of sources, but more advanced behavior can be accessed by creating a MediaPlaybackItem from the MediaSource. Il inclut la possibilité d’accéder et de gérer plusieurs pistes audio, vidéo et de données pour un élément multimédia.This includes the ability to access and manage multiple audio, video, and data tracks for a media item.

Déclarez une variable pour stocker votre MediaPlaybackItem.Declare a variable to store your MediaPlaybackItem.

MediaPlaybackItem _mediaPlaybackItem;

Créez un MediaPlaybackItem en appelant le constructeur et en le transmettant à un objet MediaSource initialisé.Create a MediaPlaybackItem by calling the constructor and passing in an initialized MediaSource object.

Si votre application prend en charge plusieurs pistes audio, vidéo ou de données dans un élément de lecture multimédia, inscrivez les gestionnaires d’événements pour les événements AudioTracksChanged, VideoTracksChangedou TimedMetadataTracksChanged .If your app supports multiple audio, video, or data tracks in a media playback item, register event handlers for the AudioTracksChanged, VideoTracksChanged, or TimedMetadataTracksChanged events.

Enfin, définissez la source de la lecture de MediaElement ou MediaPlayer sur votre MediaPlaybackItem.Finally, set the playback source of the MediaElement or MediaPlayer to your MediaPlaybackItem.

_mediaSource = MediaSource.CreateFromStorageFile(file);
_mediaPlaybackItem = new MediaPlaybackItem(_mediaSource);

_mediaPlaybackItem.AudioTracksChanged += PlaybackItem_AudioTracksChanged;
_mediaPlaybackItem.VideoTracksChanged += MediaPlaybackItem_VideoTracksChanged;
_mediaPlaybackItem.TimedMetadataTracksChanged += MediaPlaybackItem_TimedMetadataTracksChanged;

_mediaPlayer = new MediaPlayer();
_mediaPlayer.Source = _mediaPlaybackItem;
mediaPlayerElement.SetMediaPlayer(_mediaPlayer);

Notes

Un MediaSource ne peut être associé qu’à un seul MediaPlaybackItem.A MediaSource can only be associated with a single MediaPlaybackItem. Après avoir créé un MediaPlaybackItem à partir d’une source, toute tentative de création d’un autre élément de lecture à partir de la même source entraîne une erreur.After creating a MediaPlaybackItem from a source, attempting to create another playback item from the same source will result in an error. De plus, après avoir créé un MediaPlaybackItem à partir d’une source de média, vous ne pouvez pas définir l’objet MediaSource directement en tant que source d’un MediaPlayer, mais vous devez plutôt utiliser le MediaPlaybackItem.Also, after creating a MediaPlaybackItem from a media source, you can't set the MediaSource object directly as the source for a MediaPlayer but should instead use the MediaPlaybackItem.

L’événement VideoTracksChanged est déclenché après qu’un MediaPlaybackItem contenant plusieurs pistes vidéo a été attribué en tant que source de lecture, et peut être redéclenché si la liste des pistes vidéo change pour l’élément.The VideoTracksChanged event is raised after a MediaPlaybackItem containing multiple video tracks is assigned as a playback source, and can be raised again if the list of video tracks changes for the item changes. Le gestionnaire de cet événement vous permet de mettre à jour votre interface utilisateur, permettant ainsi à l’utilisateur de basculer entre les pistes disponibles.The handler for this event gives you the opportunity to update your UI to allow the user to switch between available tracks. Cet exemple utilise une zone de liste déroulante pour afficher les pistes vidéo disponibles.This example uses a ComboBox to display the available video tracks.

<ComboBox x:Name="videoTracksComboBox" SelectionChanged="videoTracksComboBox_SelectionChanged"/>

Dans le gestionnaire VideoTracksChanged, parcourez toutes les pistes de la liste VideoTracks de l’élément de lecture.In the VideoTracksChanged handler, loop through all of the tracks in the playback item's VideoTracks list. Un nouveau ComboBoxItem est créé pour chaque piste.For each track, a new ComboBoxItem is created. Si la piste ne porte déjà une étiquette, une étiquette est générée à partir de l’index de piste.If the track does not already have a label, a label is generated from the track index. La propriété Tag de l’élément de zone de liste déroulante est définie sur l’index de piste pour pouvoir l’identifier ultérieurement.The Tag property of the combo box item is set to the track index so that it can be identified later. Enfin, l’élément est ajouté à la zone de liste déroulante.Finally, the item is added to the combo box. Notez que ces opérations sont effectuées au sein d’un appel CoreDispatcher. RunAsync , car toutes les modifications de l’interface utilisateur doivent être effectuées sur le thread d’interface utilisateur et cet événement est déclenché sur un thread différent.Note that these operations are performed within a CoreDispatcher.RunAsync call because all UI changes must be made on the UI thread and this event is raised on a different thread.

private async void MediaPlaybackItem_VideoTracksChanged(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        videoTracksComboBox.Items.Clear();
        for (int index = 0; index < sender.VideoTracks.Count; index++)
        {
            var videoTrack = sender.VideoTracks[index];
            ComboBoxItem item = new ComboBoxItem();
            item.Content = String.IsNullOrEmpty(videoTrack.Label) ? $"Track {index}" : videoTrack.Label;
            item.Tag = index;
            videoTracksComboBox.Items.Add(item);
        }
    });
}

Dans le gestionnaire SelectionChanged de la zone de liste déroulante, l’index de piste est récupéré à partir de la propriété Tag de l’élément sélectionné.In the SelectionChanged handler for the combo box, the track index is retrieved from the selected item's Tag property. La définition de la propriété SelectedIndex de la liste VideoTracks de l’élément de lecture multimédia amène MediaElement ou MediaPlayer à basculer la piste vidéo active sur l’index spécifié.Setting the SelectedIndex property of the media playback item's VideoTracks list causes the MediaElement or MediaPlayer to switch the active video track to the specified index.

private void videoTracksComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    int trackIndex = (int)((ComboBoxItem)((ComboBox)sender).SelectedItem).Tag;
    _mediaPlaybackItem.VideoTracks.SelectedIndex = trackIndex;
}

La gestion des éléments multimédias avec des pistes audio multiples est strictement identique à celle des pistes vidéo.Managing media items with multiple audio tracks works exactly the same as with video tracks. Gérez le AudioTracksChanged pour mettre à jour votre interface utilisateur avec les pistes audio trouvées dans la liste AudioTracks de l’élément de lecture.Handle the AudioTracksChanged to update your UI with the audio tracks found in the playback item's AudioTracks list. Lorsque l’utilisateur sélectionne une piste audio, définissez la propriété SelectedIndex de la liste AudioTracks pour que MediaElement ou MediaPlayer bascule la piste audio active sur l’index spécifié.When the user selects an audio track, set the SelectedIndex property of the AudioTracks list to cause the MediaElement or MediaPlayer to switch the active audio track to the specified index.

<ComboBox x:Name="audioTracksComboBox" SelectionChanged="audioTracksComboBox_SelectionChanged"/>
private async void PlaybackItem_AudioTracksChanged(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        audioTracksComboBox.Items.Clear();
        for (int index = 0; index < sender.AudioTracks.Count; index++)
        {
            var audioTrack = sender.AudioTracks[index];
            ComboBoxItem item = new ComboBoxItem();
            item.Content = String.IsNullOrEmpty(audioTrack.Label) ? $"Track {index}" : audioTrack.Label;
            item.Tag = index;
            videoTracksComboBox.Items.Add(item);
        }
    });
}
private void audioTracksComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    int trackIndex = (int)((ComboBoxItem)((ComboBox)sender).SelectedItem).Tag;
    _mediaPlaybackItem.AudioTracks.SelectedIndex = trackIndex;
}

En plus de l’audio et de la vidéo, un objet MediaPlaybackItem peut contenir zéro ou plusieurs objets TimedMetadataTrack.In addition to audio and video, a MediaPlaybackItem object may contain zero or more TimedMetadataTrack objects. Une piste de métadonnées synchronisée peut contenir du texte de sous-titre. Elle peut également contenir des données personnalisées propriétaires de votre application.A timed metadata track can contain subtitle or caption text, or it may contain custom data that is proprietary to your app. Une piste de métadonnées minutée contient une liste de signaux représentés par des objets qui héritent de IMediaCue, tels qu’un DataCue ou un TimedTextCue.A timed metadata track contains a list of cues represented by objects that inherit from IMediaCue, such as a DataCue or a TimedTextCue. Chaque indicateur a une heure de début et une durée qui déterminent quand l’indicateur est activé et pour combien de temps.Each cue has a start time and a duration that determines when the cue is activated and for how long.

Comme les pistes audio et vidéo, les pistes de métadonnées synchronisées d’un élément multimédia peuvent être détectées en gérant l’événement TimedMetadataTracksChanged d’un MediaPlaybackItem.Similar to audio tracks and video tracks, the timed metadata tracks for a media item can be discovered by handling the TimedMetadataTracksChanged event of a MediaPlaybackItem. Toutefois, avec les pistes de métadonnées synchronisées, l’utilisateur souhaitera peut-être activer plusieurs pistes de métadonnées simultanément.With timed metadata tracks, however, the user may want to enable more than one metadata track at a time. De plus, en fonction de votre scénario d’application, vous souhaiterez peut-être activer ou désactiver automatiquement des pistes de métadonnées, sans l’intervention de l’utilisateur.Also, depending on your app scenario, you may want to enable or disable metadata tracks automatically, without user intervention. À des fins d’illustration, cet exemple ajoute un ToggleButton pour chaque piste de métadonnées dans un élément multimédia pour permettre à l’utilisateur d’activer et de désactiver la piste. La propriété tag de chaque bouton est définie sur l’index de la piste des métadonnées associée afin qu’il puisse être identifié lorsque le bouton est activé.For illustration purposes, this example adds a ToggleButton for each metadata track in a media item to allow the user to enable and disable the track. The Tag property of each button is set to the index of the associated metadata track so that it can be identified when the button is toggled.

<StackPanel x:Name="MetadataButtonPanel" Orientation="Horizontal"/>
private async void MediaPlaybackItem_TimedMetadataTracksChanged(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        for (int index = 0; index < sender.TimedMetadataTracks.Count; index++)
        {
            var timedMetadataTrack = sender.TimedMetadataTracks[index];

            ToggleButton toggle = new ToggleButton()
            {
                Content = String.IsNullOrEmpty(timedMetadataTrack.Label) ? $"Track {index}" : timedMetadataTrack.Label,
                Tag = (uint)index
            };
            toggle.Checked += Toggle_Checked;
            toggle.Unchecked += Toggle_Unchecked;

            MetadataButtonPanel.Children.Add(toggle);
        }
    });
}

Étant donné que plusieurs pistes de métadonnées peuvent être actives simultanément, vous ne définissez pas simplement l’index actif de la liste de pistes de métadonnées.Because more than one metadata track can be active at a time, you don't simply set the active index for the metadata track list. Appelez plutôt le MediaPlaybackItem de la méthode SetPresentationMode de l’objet, en indiquant l’index de la piste que vous souhaitez activer/désactiver, puis en spécifiant une valeur à partir de l’énumération TimedMetadataTrackPresentationMode.Instead, call the MediaPlaybackItem object's SetPresentationMode method, passing in the index of the track you want to toggle, and then providing a value from the TimedMetadataTrackPresentationMode enumeration. Le mode de présentation que vous choisissez dépend de l’implémentation de votre application.The presentation mode you choose depends on the implementation of your app. Dans cet exemple, la piste de métadonnées est définie sur PlatformPresented lorsqu’elle est activée.In this example, the metadata track is set to PlatformPresented when enabled. Pour les pistes textuelles, cela signifie que le système affichera automatiquement les indications de texte dans la piste. Quand le bouton bascule est désactivé, le mode de présentation est défini sur désactivé, ce qui signifie qu’aucun texte n’est affiché et qu’aucun événement de signal n’est déclenché.For text-based tracks, this means that the system will automatically display the text cues in the track. When the toggle button is toggled off, the presentation mode is set to Disabled, which means that no text is displayed and no cue events are raised. Les événements d’indicateur sont présentés plus loin dans cet article.Cue events are discussed later in this article.

private void Toggle_Checked(object sender, RoutedEventArgs e) =>         
    _mediaPlaybackItem.TimedMetadataTracks.SetPresentationMode((uint)((ToggleButton)sender).Tag,
        TimedMetadataTrackPresentationMode.PlatformPresented);
private void Toggle_Unchecked(object sender, RoutedEventArgs e) =>         
    _mediaPlaybackItem.TimedMetadataTracks.SetPresentationMode((uint)((ToggleButton)sender).Tag,
        TimedMetadataTrackPresentationMode.Disabled);

Lorsque vous traitez les pistes de métadonnées, vous pouvez accéder à l’ensemble de signaux au sein de la piste en accédant aux propriétés des indications ou ActiveCues .As you are processing the metadata tracks, you can access the set of cues within the track by accessing the Cues or ActiveCues properties. Pour ce faire, mettez à jour votre interface utilisateur pour afficher les emplacements de repère d’un élément multimédia.You can do this to update your UI to show the cue locations for a media item.

Gérer les codecs non pris en charge et les erreurs inconnues à l’ouverture des éléments multimédiasHandle unsupported codecs and unknown errors when opening media items

À compter de Windows 10, version 1607, vous pouvez vérifier si le codec nécessaire pour lire un élément multimédia est pris en charge entièrement ou partiellement sur l’appareil sur lequel s’exécute votre application.Starting with Windows 10, version 1607, you can check whether the codec required to playback a media item is supported or partially supported on the device on which your app is running. Dans le gestionnaire d’événements pour les événements MediaPlaybackItem Tracks-Changed, tels que AudioTracksChanged, commencez par vérifier si la modification de piste est l’insertion d’une nouvelle piste. Dans ce cas, vous pouvez obtenir une référence à la piste en cours d’insertion à l’aide de l’index passé dans le paramètre IVectorChangedEventArgs. index avec la collection de pistes appropriée du paramètre MediaPlaybackItem , telle que la collection AudioTracks .In the event handler for the MediaPlaybackItem tracks-changed events, such as AudioTracksChanged, first check to see if the track change is an insertion of a new track. If so, you can get a reference to the track being inserted by using the index passed in the IVectorChangedEventArgs.Index parameter with the appropriate track collection of the MediaPlaybackItem parameter, such as the AudioTracks collection.

Une fois que vous avez une référence à la piste insérée, vérifiez le DecoderStatus de la propriété SupportInfo de la piste.Once you have a reference to the inserted track, check the DecoderStatus of the track's SupportInfo property. Si la valeur est FullySupported, le codec approprié nécessaire pour lire la piste est présent sur l’appareil.If the value is FullySupported, then the appropriate codec needed to play back the track is present on the device. Si la valeur est Degraded, la piste peut être lue par le système, mais la lecture est détériorée d’une certaine façon.If the value is Degraded, then the track can be played by the system, but the playback will be degraded in some way. Par exemple, une piste audio 5.1 peut être lue à la place comme une piste stéréo bicanale.For example, a 5.1 audio track may be played back as 2-channel stereo instead. Si c’est le cas, vous pouvez mettre à jour votre interface utilisateur pour alerter l’utilisateur de la détérioration.If this is the case, you may want to update your UI to alert the user of the degradation. Si la valeur est UnsupportedSubtype ou UnsupportedEncoderProperties, la piste ne peut pas être lue avec les codecs actuels sur l’appareil.If the value is UnsupportedSubtype or UnsupportedEncoderProperties, then the track can't be played back at all with the current codecs on the device. Vous pouvez alerter l’utilisateur et ignorez la lecture de l’élément ou implémenter une interface utilisateur pour permettre à l’utilisateur de télécharger le codec correct.You may wish to alert the user and skip playback of the item or implement UI to allow the user to download the correct codec. La méthode GetEncodingProperties de la piste peut être utilisée pour déterminer le codec requis pour la lecture.The track's GetEncodingProperties method can be used to determine the required codec for playback.

Enfin, vous pouvez vous inscrire à l’événement OpenFailed de la piste, qui sera déclenché si la piste est prise en charge sur l’appareil mais n’a pas pu s’ouvrir en raison d’une erreur inconnue dans le pipeline.Finally, you can register for the track's OpenFailed event, which will be raised if the track is supported on the device but failed to open due to an unknown error in the pipeline.

private async void SnippetAudioTracksChanged_CodecCheck(MediaPlaybackItem sender, IVectorChangedEventArgs args)
{
    if (args.CollectionChange == CollectionChange.ItemInserted)
    {
        var insertedTrack = sender.AudioTracks[(int)args.Index];

        var decoderStatus = insertedTrack.SupportInfo.DecoderStatus;
        if (decoderStatus != MediaDecoderStatus.FullySupported)
        {
            if (decoderStatus == MediaDecoderStatus.Degraded)
            {
                ShowMessageToUser($"Track {insertedTrack.Name} can play but playback will be degraded. {insertedTrack.SupportInfo.DegradationReason}");
            }
            else
            {
                // status is MediaDecoderStatus.UnsupportedSubtype or MediaDecoderStatus.UnsupportedEncoderProperties
                ShowMessageToUser($"Track {insertedTrack.Name} uses an unsupported media format.");
            }

            Windows.Media.MediaProperties.AudioEncodingProperties props = insertedTrack.GetEncodingProperties();
            await HelpUserInstallCodec(props);
        }
        else
        {
            insertedTrack.OpenFailed += InsertedTrack_OpenFailed;
        }
    }

}

Dans le gestionnaire d’événements OpenFailed, vous pouvez vérifier si l’état de MediaSource est inconnu et si tel est le cas, vous pouvez sélectionner par programmation une autre piste à lire, autoriser l’utilisateur à choisir une autre piste ou abandonner la lecture.In the OpenFailed event handler, you can check to see if the MediaSource status is unknown, and if so, you can programatically select a different track to play, allow the user to choose a different track, or abandon playback.

private async void InsertedTrack_OpenFailed(AudioTrack sender, AudioTrackOpenFailedEventArgs args)
{
    LogError(args.ExtendedError.HResult);

    if (sender.SupportInfo.MediaSourceStatus == MediaSourceStatus.Unknown)
    {
        await SelectAnotherTrackOrSkipPlayback(sender.PlaybackItem);
    }
}

Définir les propriétés d’affichage utilisées par les contrôles de transport de média systèmeSet display properties used by the System Media Transport Controls

À compter de Windows 10, version 1607, le support lu dans un MediaPlayer est automatiquement intégré dans les contrôles de transport des médias système (SMTC) par défaut.Starting with Windows 10, version 1607, media played in a MediaPlayer is automatically integrated into the System Media Transport Controls (SMTC) by default. Vous pouvez spécifier les métadonnées que les contrôles de transport de média système doivent afficher en mettant à jour les propriétés d’affichage d’un MediaPlaybackItem.You can specify the metadata that will be displayed by the SMTC by updating the display properties for a MediaPlaybackItem. Obtient un objet représentant les propriétés d’affichage d’un élément en appelant GetDisplayProperties.Get an object representing the display properties for an item by calling GetDisplayProperties. Déterminez si l’élément de lecture est de la musique ou une vidéo en définissant la propriété Type.Set whether the playback item is music or video by setting the Type property. Ensuite, définissez les propriétés VideoProperties ou MusicProperties de l’objet.Then, set the properties of the object's VideoProperties or MusicProperties. Appelez ApplyDisplayProperties pour mettre à jour les propriétés de l’élément sur les valeurs que vous avez indiquées.Call ApplyDisplayProperties to update the item's properties to the values you provided. En règle générale, une application récupère les valeurs d’affichage de manière dynamique à partir d’un service web, mais l’exemple suivant illustre ce processus avec des valeurs codées en dur.Typically, an app will retrieve the display values dynamically from a web service, but the following example illustrates this process with hardcoded values.

MediaItemDisplayProperties props = mediaPlaybackItem.GetDisplayProperties();
props.Type = Windows.Media.MediaPlaybackType.Video;
props.VideoProperties.Title = "Video title";
props.VideoProperties.Subtitle = "Video subtitle";
props.VideoProperties.Genres.Add("Documentary");
mediaPlaybackItem.ApplyDisplayProperties(props);
props = mediaPlaybackItem.GetDisplayProperties();
props.Type = Windows.Media.MediaPlaybackType.Music;
props.MusicProperties.Title = "Song title";
props.MusicProperties.Artist = "Song artist";
props.MusicProperties.Genres.Add("Polka");
mediaPlaybackItem.ApplyDisplayProperties(props);

Ajouter du texte synchronisé externe avec TimedTextSourceAdd external timed text with TimedTextSource

Dans certains scénarios, vous pouvoir disposer de fichiers externes contenant du texte synchronisé associé à un élément multimédia, des fichiers distincts contenant des sous-titres pour différents paramètres régionaux par exemple.For some scenarios, you may have external files that contains timed text associated with a media item, such as separate files that contain subtitles for different locales. Utilisez la classe TimedTextSource pour charger les fichiers de texte synchronisé externe à partir d’un flux ou d’une URI.Use the TimedTextSource class to load in external timed text files from a stream or URI.

Cet exemple utilise une collection Dictionary pour stocker une liste de sources de texte synchronisé pour l’élément multimédia à l’aide de l’URI source et de l’objet TimedTextSource en tant que paire clé/valeur afin d’identifier les pistes une fois qu’elles ont été résolues.This example uses a Dictionary collection to store a list of the timed text sources for the media item using the source URI and the TimedTextSource object as the key/value pair in order to identify the tracks after they have been resolved.

Dictionary<TimedTextSource, Uri> timedTextSourceMap;

Créez un TimedTextSource pour chaque fichier de texte synchronisé externe en appelant la méthode CreateFromUri.Create a new TimedTextSource for each external timed text file by calling CreateFromUri. Ajoutez une entrée pour le Dictionary de la source de texte synchronisé.Add an entry to the Dictionary for the timed text source. Ajoutez un gestionnaire pour l’événement TimedTextSource.Resolved à gérer si l’élément n’a pas pu être chargé ou pour définir des propriétés supplémentaires lorsque l’élément a bien été chargé.Add a handler for the TimedTextSource.Resolved event to handle if the item failed to load or to set additional properties after the item was loaded successfully.

Inscrivez tous vos objets TimedTextSource avec MediaSource en les ajoutant à la collection ExternalTimedTextSources.Register all of your TimedTextSource objects with the MediaSource by adding them to the ExternalTimedTextSources collection. Notez que les sources de texte synchronisé externe sont ajoutées directement à MediaSource et non au MediaPlaybackItem créé à partir de la source.Note that external timed text sources are added to directly the MediaSource and not the MediaPlaybackItem created from the source. Pour mettre à jour votre interface utilisateur afin de refléter les pistes de texte externe, inscrivez et gérez l’événement TimedMetadataTracksChanged comme décrit précédemment dans cet article.To update your UI to reflect the external text tracks, register and handle the TimedMetadataTracksChanged event as described previously in this article.

// Create the TimedTextSource and add entry to URI map
var timedTextSourceUri_En = new Uri("http://contoso.com/MyClipTimedText_en.srt");
var timedTextSource_En = TimedTextSource.CreateFromUri(timedTextSourceUri_En);
timedTextSourceMap[timedTextSource_En] = timedTextSourceUri_En;
timedTextSource_En.Resolved += TimedTextSource_Resolved;

var timedTextSourceUri_Pt = new Uri("http://contoso.com/MyClipTimedText_pt.srt");
var timedTextSource_Pt = TimedTextSource.CreateFromUri(timedTextSourceUri_Pt);
timedTextSourceMap[timedTextSource_Pt] = timedTextSourceUri_Pt;
timedTextSource_Pt.Resolved += TimedTextSource_Resolved;

// Add the TimedTextSource to the MediaSource
_mediaSource.ExternalTimedTextSources.Add(timedTextSource_En);
_mediaSource.ExternalTimedTextSources.Add(timedTextSource_Pt);

_mediaPlaybackItem = new MediaPlaybackItem(_mediaSource);
_mediaPlaybackItem.TimedMetadataTracksChanged += MediaPlaybackItem_TimedMetadataTracksChanged;

_mediaPlayer = new MediaPlayer();
_mediaPlayer.Source = _mediaPlaybackItem;
mediaPlayerElement.SetMediaPlayer(_mediaPlayer);

Dans le gestionnaire de l’événement TimedTextSource.Resolved, vérifiez la propriété Error de TimedTextSourceResolveResultEventArgs transmise au gestionnaire pour déterminer si une erreur s’est produite lors de la tentative de chargement des données de texte synchronisé.In the handler for the TimedTextSource.Resolved event, check the Error property of the TimedTextSourceResolveResultEventArgs passed into the handler to determine if an error occurred while trying to load the timed text data. Si l’élément a été résolu avec succès, vous pouvez utiliser ce gestionnaire pour mettre à jour les propriétés supplémentaires de la piste résolue. Cet exemple ajoute une étiquette pour chaque piste en fonction de l’URI précédemment stocké dans le dictionnaire.If the item was resolved successfully, you can use this handler to update additional properties of the resolved track. This example adds a label for each track based on the URI previously stored in the Dictionary.

private void TimedTextSource_Resolved(TimedTextSource sender, TimedTextSourceResolveResultEventArgs args)
{
    var timedTextSourceUri = timedTextSourceMap[sender];

    if (!(args.Error is null))
    {
        // Show that there was an error in your UI
        ShowMessageToUser($"There was an error resolving track: {timedTextSourceUri}");
        return;
    }

    // Add a label for each resolved track
    var timedTextSourceUriString = timedTextSourceUri.AbsoluteUri;
    if (timedTextSourceUriString.Contains("_en"))
    {
        args.Tracks[0].Label = "English";
    }
    else if (timedTextSourceUriString.Contains("_pt"))
    {
        args.Tracks[0].Label = "Portuguese";
    }
}

Ajouter des pistes de métadonnées supplémentairesAdd additional metadata tracks

Vous pouvez créer des pistes de métadonnées personnalisées de manière dynamique dans le code et les associer à une source de média.You can dynamically create custom metadata tracks in code and associate them with a media source. Les pistes que vous créez peuvent contenir du texte de sous-titre. Elles peuvent également contenir vos données d’application propriétaires.The tracks you create can contain subtitle or caption text, or they can contain your proprietary app data.

Créez un TimedMetadataTrack en appelant le constructeur et en spécifiant un ID, l’identificateur de langue et une valeur de l’énumération TimedMetadataKind.Create a new TimedMetadataTrack by calling the constructor and specifying an ID, the language identifier, and a value from the TimedMetadataKind enumeration. Enregistrez des gestionnaires pour les événements CueEntered et CueExited.Register handlers for the CueEntered and CueExited events. Ces événements sont déclenchés lorsque l’heure de début d’un indicateur est atteinte et lorsque la durée d’un indicateur s’est écoulée, respectivement.These events are raised when the start time for a cue has been reached and when the duration for a cue has expired, respectively.

Créez un objet de signal, approprié pour le type de suivi de métadonnées que vous avez créé, et définissez l’ID, l’heure de début et la durée de la piste. Cet exemple crée une piste de données, donc un ensemble d’objets DataCue sont générés et une mémoire tampon contenant des données spécifiques à l’application est fournie pour chaque pile.Create a new cue object, appropriate for the type of metadata track you created, and set the ID, start time, and duration for the track. This example creates a data track, so a set of DataCue objects are generated and a buffer containing app-specific data is provided for each cue. Pour inscrire la nouvelle piste, ajoutez-la à la collection ExternalTimedMetadataTracks de l’objet MediaSource.To register the new track, add it to the ExternalTimedMetadataTracks collection of the MediaSource object.

À compter de Windows 10, version 1703, la propriété DataCue. Properties expose un PropertySet que vous pouvez utiliser pour stocker des propriétés personnalisées dans des paires clé/données qui peuvent être récupérées dans les événements CueEntered et CueExited .Starting with Windows 10, version 1703, the DataCue.Properties property exposes a PropertySet that you can use to store custom properties in key/data pairs that can be retrieved in the CueEntered and CueExited events.

TimedMetadataTrack metadataTrack = new TimedMetadataTrack("ID_0", "en-us", TimedMetadataKind.Data);
metadataTrack.Label = "Custom data track";
metadataTrack.CueEntered += MetadataTrack_DataCueEntered;
metadataTrack.CueExited += MetadataTrack_CueExited;

// Example cue data
string data = "Cue data";
byte[] bytes = new byte[data.Length * sizeof(char)];
System.Buffer.BlockCopy(data.ToCharArray(), 0, bytes, 0, bytes.Length);
Windows.Storage.Streams.IBuffer buffer = bytes.AsBuffer();

for (int i = 0; i < 10; i++)
{
    DataCue cue = new DataCue();
    cue.Id = "ID_" + i;
    cue.Data = buffer;
    cue.Properties["AdUrl"] = "http://contoso.com/ads/123";
    cue.StartTime = TimeSpan.FromSeconds(3 + i * 3);
    cue.Duration = TimeSpan.FromSeconds(2);

    metadataTrack.AddCue(cue);
}

_mediaSource.ExternalTimedMetadataTracks.Add(metadataTrack);

L’événement CueEntered est déclenché lorsque l’heure de début d’un indicateur est atteinte alors que la piste associée dispose d’un mode de présentation ApplicationPresented, Hidden ou PlatformPresented..The CueEntered event is raised when a cue's start time has been reached as long as the associated track has a presentation mode of ApplicationPresented, Hidden, or PlatformPresented. Les événements d’indicateur ne sont pas déclenchés pour les pistes de métadonnées lorsque le mode de présentation de la piste est Disabled.Cue events are not raised for metadata tracks while the presentation mode for the track is Disabled. Cet exemple présente simplement les données personnalisées associées à l’indicateur dans la fenêtre de débogage.This example simply outputs the custom data associated with the cue to the debug window.

private void MetadataTrack_DataCueEntered(TimedMetadataTrack sender, MediaCueEventArgs args)
{
    DataCue cue = (DataCue)args.Cue;
    string data = System.Text.Encoding.Unicode.GetString(cue.Data.ToArray());
    System.Diagnostics.Debug.WriteLine("Cue entered: " + data);
    System.Diagnostics.Debug.WriteLine("Custom prop value: " + cue.Properties["AdUrl"]);
}

Cet exemple ajoute une piste de texte personnalisé en spécifiant TimedMetadataKind.Caption lors de la création de la piste et de l’utilisation d’objets TimedTextCue pour ajouter des indicateurs à la piste.This example adds a custom text track by specifying TimedMetadataKind.Caption when creating the track and using TimedTextCue objects to add cues to the track.

TimedMetadataTrack metadataTrack = new TimedMetadataTrack("TrackID_0", "en-us", TimedMetadataKind.Caption);
metadataTrack.Label = "Custom text track";
metadataTrack.CueEntered += MetadataTrack_TextCueEntered;

for (int i = 0; i < 10; i++)
{
    TimedTextCue cue = new TimedTextCue()
    {
        Id = "TextCueID_" + i,
        StartTime = TimeSpan.FromSeconds(i * 3),
        Duration = TimeSpan.FromSeconds(2)
    };

    cue.Lines.Add(new TimedTextLine() { Text = "This is a custom timed text cue." });
    metadataTrack.AddCue(cue);
}

_mediaSource.ExternalTimedMetadataTracks.Add(metadataTrack);
private void MetadataTrack_TextCueEntered(TimedMetadataTrack sender, MediaCueEventArgs args)
{
    TimedTextCue cue = (TimedTextCue)args.Cue;
    System.Diagnostics.Debug.WriteLine("Cue entered: " + cue.Id + " " + cue.Lines[0].Text);
}

Lire une liste d’éléments multimédias avec MediaPlaybackListPlay a list of media items with MediaPlaybackList

MediaPlaybackList vous permet de créer une playlist d’éléments multimédias, qui sont représentés par des objets MediaPlaybackItem.The MediaPlaybackList allows you to create a playlist of media items, which are represented by MediaPlaybackItem objects.

Remarque    Les éléments d’un MediaPlaybackList sont rendus à l’aide de la lecture ininterrompue.Note  Items in a MediaPlaybackList are rendered using gapless playback. Le système utilise les métadonnées fournies dans les fichiers codés MP3 ou AAC pour déterminer la compensation de délai ou de remplissage nécessaire pour la lecture sans blanc.The system will use provided metadata in MP3 or AAC encoded files to determine the delay or padding compensation needed for gapless playback. Si les fichiers codés MP3 ou AAC ne fournissent pas ces métadonnées, le système détermine alors le délai ou le remplissage de manière heuristique.If the MP3 or AAC encoded files don't provide this metadata, then the system determines the delay or padding heuristically. Pour les formats sans perte, tels que PCM, FLAC ou ALAC, le système n’exécute aucune action, car ces encodeurs n’introduisent ni retard ni remplissage.For lossless formats, such as PCM, FLAC, or ALAC, the system takes no action because these encoders don't introduce delay or padding.

Pour commencer, déclarez une variable pour stocker votre MediaPlaybackList.To get started, declare a variable to store your MediaPlaybackList.

MediaPlaybackList _mediaPlaybackList;

Créez un MediaPlaybackItem pour chaque élément multimédia que vous voulez ajouter à votre liste en suivant la procédure décrite précédemment dans cet article.Create a MediaPlaybackItem for each media item you want to add to your list using the same procedure described previously in this article. Initialisez votre objet MediaPlaybackList et ajoutez-y les éléments de lecture multimédia.Initialize your MediaPlaybackList object and add the media playback items to it. Inscrivez un gestionnaire pour l’événement CurrentItemChanged.Register a handler for the CurrentItemChanged event. Cet événement vous permet de mettre à jour votre interface utilisateur afin de refléter l’élément multimédia en cours de lecture.This event allows you to update your UI to reflect the currently playing media item. Vous pouvez également vous inscrire à l’événement ItemOpened , qui est déclenché lorsqu’un élément de la liste est ouvert avec succès, et l’événement ItemFailed , qui est déclenché lorsqu’un élément de la liste ne peut pas être ouvert.You can also register for the ItemOpened event, which is raised when an item in the list is successfully opened, and the ItemFailed event, which is raised when an item in the list can't be opened.

À compter de Windows 10, version 1703, vous pouvez spécifier le nombre maximal d’objets MediaPlaybackItem dans le MediaPlaybackList que le système reste ouvert après avoir été lu en définissant la propriété MaxPlayedItemsToKeepOpen .Starting with Windows 10, version 1703, you can specify the maximum number of MediaPlaybackItem objects in the MediaPlaybackList that the system will keep open after they have been played by setting the MaxPlayedItemsToKeepOpen property. Quand un MediaPlaybackItem est maintenu ouvert, la lecture de l’élément peut démarrer instantanément lorsque l’utilisateur bascule sur cet élément, car l’élément n’a pas besoin d’être rechargé.When a MediaPlaybackItem is kept open, playback of the item can start instantaneously when the user switches to that item because the item doesn't need to be reloaded. Toutefois, conserver les éléments ouverts augmente également la consommation de mémoire de votre application. vous devez donc prendre en compte l’équilibre entre la réactivité et l’utilisation de la mémoire lors de la définition de cette valeur.But keeping items open also increases the memory consumption of your app, so you should consider the balance between responsiveness and memory usage when setting this value.

Pour activer la lecture de votre liste, définissez la source de lecture du MediaPlayer sur votre MediaPlaybackList.To enable playback of your list, set the playback source of the MediaPlayer to your MediaPlaybackList.

_mediaPlaybackList = new MediaPlaybackList();

var files = await filePicker.PickMultipleFilesAsync();

foreach (var file in files)
{
    var mediaPlaybackItem = new MediaPlaybackItem(MediaSource.CreateFromStorageFile(file));
    _mediaPlaybackList.Items.Add(mediaPlaybackItem);
}

_mediaPlaybackList.CurrentItemChanged += MediaPlaybackList_CurrentItemChanged;
_mediaPlaybackList.ItemOpened += MediaPlaybackList_ItemOpened;
_mediaPlaybackList.ItemFailed += MediaPlaybackList_ItemFailed;

_mediaPlaybackList.MaxPlayedItemsToKeepOpen = 3;

_mediaPlayer = new MediaPlayer();
_mediaPlayer.Source = _mediaPlaybackList;
mediaPlayerElement.SetMediaPlayer(_mediaPlayer);

Dans le gestionnaire d’événements CurrentItemChanged, mettez à jour votre interface utilisateur afin de refléter l’élément en cours de lecture, qui peut être récupéré à l’aide de la propriété NewItem de l’objet CurrentMediaPlaybackItemChangedEventArgs transmis dans l’événement.In the CurrentItemChanged event handler, update your UI to reflect the currently playing item, which can be retrieved using the NewItem property of the CurrentMediaPlaybackItemChangedEventArgs object passed into the event. N’oubliez pas que si vous mettez à jour l’interface utilisateur à partir de cet événement, vous devez le faire dans le cadre d’un appel à CoreDispatcher.RunAsync afin que les mises à jour soient effectuées sur le thread d’interface utilisateur.Remember that if you update the UI from this event, you should do so within a call to CoreDispatcher.RunAsync so that the updates are made on the UI thread.

À compter de Windows 10, la version 1703, vous pouvez vérifier la propriété CurrentMediaPlaybackItemChangedEventArgs. Reason pour obtenir une valeur qui indique la raison pour laquelle l’élément a changé, par exemple les éléments de changement d’application par programmation, l’élément en cours d’exécution qui a atteint sa fin, ou une erreur se produisant.Starting with Windows 10, version 1703, you can check the CurrentMediaPlaybackItemChangedEventArgs.Reason property to get a value that indicates the reason that the item changed, such as the app switching items programatically, the previously playing item reaching its end, or an error occurring.

private void MediaPlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args) => 
    LogTelemetryData($"CurrentItemChanged reason: {args.Reason.ToString()}");

Appelez MovePrevious ou MoveNext pour que le lecteur multimédia lise l’élément précédent ou suivant de votre MediaPlaybackList.Call MovePrevious or MoveNext to cause the media player to play the previous or next item in your MediaPlaybackList.

private void prevButton_Click(object sender, RoutedEventArgs e) =>  _mediaPlaybackList.MovePrevious();
private void nextButton_Click(object sender, RoutedEventArgs e) => _mediaPlaybackList.MoveNext();

Définissez la propriété ShuffleEnabled pour spécifier si le lecteur multimédia doit lire les éléments de votre liste dans un ordre aléatoire.Set the ShuffleEnabled property to specify whether the media player should play the items in your list in random order.

private async void shuffleButton_Click(object sender, RoutedEventArgs e)
{
    _mediaPlaybackList.ShuffleEnabled = !_mediaPlaybackList.ShuffleEnabled;

    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        shuffleButton.FontWeight =
            _mediaPlaybackList.ShuffleEnabled ? Windows.UI.Text.FontWeights.Bold : Windows.UI.Text.FontWeights.Light;
    });
}

Définissez la propriété AutoRepeatEnabled pour spécifier si le lecteur multimédia doit lire votre liste en boucle.Set the AutoRepeatEnabled property to specify whether the media player should loop playback of your list.

private async void autoRepeatButton_Click(object sender, RoutedEventArgs e)
{
    _mediaPlaybackList.AutoRepeatEnabled = !_mediaPlaybackList.AutoRepeatEnabled;

    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
    {
        autoRepeatButton.FontWeight =
            _mediaPlaybackList.AutoRepeatEnabled ? Windows.UI.Text.FontWeights.Bold : Windows.UI.Text.FontWeights.Light;
    });
}

Gérer l’échec d’éléments multimédias dans une liste de lectureHandle the failure of media items in a playback list

L’événement ItemFailed est déclenché lorsqu’un élément de la liste ne parvient pas à s’ouvrir.The ItemFailed event is raised when an item in the list fails to open. La propriété ErrorCode de l’objet MediaPlaybackItemError transmis au gestionnaire énumère la cause spécifique de l’échec dans la mesure du possible, y compris les erreurs réseau, les erreurs de décodage ou les erreurs de chiffrement.The ErrorCode property of the MediaPlaybackItemError object passed into the handler enumerates the specific cause of the failure when possible, including network errors, decoding errors, or encryption errors.

private void MediaPlaybackList_ItemFailed(MediaPlaybackList sender, MediaPlaybackItemFailedEventArgs args)
{
    LogError(args.Error.ErrorCode.ToString());
    LogError(args.Error.ExtendedError.HResult);
}

Désactiver la lecture des éléments dans une liste de lectureDisable playback of items in a playback list

À compter de Windows 10, version 1703, vous pouvez désactiver la lecture d’un ou plusieurs éléments dans un MediaPlaybackItemList en affectant à la propriété IsDisabledInPlaybackList d’un MediaPlaybackItem la valeur false.Starting with Windows 10, version 1703, you can disable playback of one or more items in a MediaPlaybackItemList by setting the IsDisabledInPlaybackList property of a MediaPlaybackItem to false.

Un scénario classique pour cette fonctionnalité est pour les applications qui lisent de la musique en continu à partir d’Internet.A typical scenario for this feature is for apps that play music streamed from the internet. L’application peut écouter les modifications de l’état de la connexion réseau de l’appareil et désactiver la lecture des éléments qui ne sont pas entièrement téléchargés.The app can listen for changes in the network connection status of the device and disable playback of items that are not fully downloaded. Dans l’exemple suivant, un gestionnaire est inscrit pour l’événement NetworkInformation. NetworkStatusChanged .In the following example, a handler is registered for the NetworkInformation.NetworkStatusChanged event.

Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += NetworkInformation_NetworkStatusChanged;

Dans le gestionnaire de NetworkStatusChanged, vérifiez si GetInternetConnectionProfile retourne la valeur null, ce qui indique que le réseau n’est pas connecté.In the handler for NetworkStatusChanged, check to see if GetInternetConnectionProfile returns null, which indicates that the network is not connected. Si c’est le cas, Parcourez tous les éléments de la liste de lecture et, si la TotalDownloadProgress de l’élément est inférieure à 1, ce qui signifie que l’élément n’a pas été entièrement téléchargé, désactivez l’élément.If this is the case, loop through all of the items in the playback list, and if the TotalDownloadProgress for the item is less than 1, meaning that the item has not fully downloaded, disable the item. Si la connexion réseau est activée, Parcourez tous les éléments de la liste de lecture et activez chaque élément.If the network connection is enabled, loop through all of the items in the playback list and enable each item.

private void NetworkInformation_NetworkStatusChanged(object sender)
{
    if (Windows.Networking.Connectivity.NetworkInformation.GetInternetConnectionProfile() == null)
    {
        // Check download status of each item in the list. (TotalDownloadProgress < 1 means not completely downloaded)
        foreach (var item in _mediaPlaybackList.Items)
        {
            if (item.TotalDownloadProgress < 1)
            {
                item.IsDisabledInPlaybackList = true;
            }
        }
    }
    else
    {
        // Connected to internet, re-enable all playlist items
        foreach (var item in _mediaPlaybackList.Items)
        {
            item.IsDisabledInPlaybackList = true;
        }
    }
}

Différer la liaison du contenu multimédia pour les éléments d’une liste de lecture à l’aide de MediaBinderDefer binding of media content for items in a playback list by using MediaBinder

Dans les exemples précédents, une MediaSource est créée à partir d’un fichier, d’une URL ou d’un flux, après quoi un MediaPlaybackItem est créé et ajouté à un MediaPlaybackList.In the previous examples, a MediaSource is created from a file, URL, or stream, after which a MediaPlaybackItem is created and added to a MediaPlaybackList. Pour certains scénarios, par exemple, si l’utilisateur est facturé pour afficher du contenu, vous pouvez différer la récupération du contenu d’un MediaSource jusqu’à ce que l’élément de la liste de lecture soit prêt à être lu.For some scenarios, such as if the user is being charged for viewing content, you may want to defer the retrieval of the content of a MediaSource until the item in the playback list is ready to actually be played. Pour implémenter ce scénario, créez une instance de la classe MediaBinder .To implement this scenario, create an instance of the MediaBinder class. Affectez à la propriété Token une chaîne définie par l’application qui identifie le contenu pour lequel vous souhaitez différer la récupération, puis enregistrez un gestionnaire pour l’événement de liaison .Set the Token property to an app-defined string that identifies the content for which you want to defer retrieval and then register a handler for the Binding event. Créez ensuite un MediaSource à partir du Binder en appelant MediaSource. CreateFromMediaBinder.Next, create a MediaSource from the Binder by calling MediaSource.CreateFromMediaBinder. Créez ensuite un MediaPlaybackItem à partir du MediaSource et ajoutez-le à la liste de lecture comme d’habitude.Then, create a MediaPlaybackItem from the MediaSource and add it to the playback list as usual.

_mediaPlaybackList = new MediaPlaybackList();

var binder = new MediaBinder();
binder.Token = "MyBindingToken1";
binder.Binding += Binder_Binding;
_mediaPlaybackList.Items.Add(new MediaPlaybackItem(MediaSource.CreateFromMediaBinder(binder)));

binder = new MediaBinder();
binder.Token = "MyBindingToken2";
binder.Binding += Binder_Binding;
_mediaPlaybackList.Items.Add(new MediaPlaybackItem(MediaSource.CreateFromMediaBinder(binder)));

_mediaPlayer = new MediaPlayer();
_mediaPlayer.Source = _mediaPlaybackList;
mediaPlayerElement.SetMediaPlayer(_mediaPlayer);

Lorsque le système détermine que le contenu associé à l' MediaBinder doit être récupéré, il déclenche l’événement de liaison .When the system determines that the content associated with the MediaBinder needs to be retrieved, it will raise the Binding event. Dans le gestionnaire de cet événement, vous pouvez récupérer l’instance MediaBinder à partir du MediaBindingEventArgs passé dans l’événement.In the handler for this event, you can retrieve the MediaBinder instance from the MediaBindingEventArgs passed into the event. Récupérez la chaîne que vous avez spécifiée pour la propriété de jeton et utilisez-la pour déterminer le contenu à récupérer.Retrieve the string you specified for the Token property and use it to determine what content should be retrieved. MediaBindingEventArgs fournit des méthodes pour définir le contenu lié dans plusieurs représentations différentes, y compris SetStorageFile, SetStream, SetStreamReferenceet SetUri.The MediaBindingEventArgs provides methods for setting the bound content in several different representations, including SetStorageFile, SetStream, SetStreamReference, and SetUri.

private void Binder_Binding(MediaBinder sender, MediaBindingEventArgs args)
{
    // Get a deferral if you need to perform async operations
    // var deferral = args.GetDeferral();

    var contentUri = new Uri("http://contoso.com/media/" + args.MediaBinder.Token);
    args.SetUri(contentUri);

    // Call complete after your async operations are complete
    // deferral.Complete();
}

Notez que si vous effectuez des opérations asynchrones, telles que des requêtes Web, dans le gestionnaire d’événements de liaison , vous devez appeler la méthode MediaBindingEventArgs. GetDeferral pour indiquer au système d’attendre que l’opération se termine avant de continuer.Note that if you are performing asynchronous operations, such as web requests, in the Binding event handler, you should call the MediaBindingEventArgs.GetDeferral method to instruct the system to wait for your operation to complete before continuing. Appelez Report. Complete une fois l’opération terminée pour demander au système de continuer.Call Deferral.Complete after your operation is complete to instruct the system to continue.

À compter de Windows 10, version 1703, vous pouvez fournir un AdaptiveMediaSource comme contenu lié en appelant SetAdaptiveMediaSource.Starting with Windows 10, version 1703, you can supply an AdaptiveMediaSource as bound content by calling SetAdaptiveMediaSource. Pour plus d’informations sur l’utilisation de la diffusion adaptative en continu dans votre application, consultez streaming adaptative.For more information on using adaptive streaming in your app, see Adaptive streaming.