Как играть фоновую музыку в Windows Phone 8.1 с XAML и C#?

Question

Я много искал, через сайт msdn, stackru и т. Д., Но я не могу воспроизвести песню в фоновом режиме. Он останавливается при смене фрейма или при выходе из приложения, возвращающегося к запуску, он также запускается случайным образом, когда находится на экране блокировки или в других местах. Не могли бы вы объяснить, как правильно этот код, пожалуйста? Извините за плохой код, но я начал несколько дней назад.

это более или менее то, что я нашел на сайте Microsoft. Там также нет системы, которая не показывает никакого контроля

public sealed partial class listView : Page
{
     SystemMediaTransportControls Player = SystemMediaTransportControls.GetForCurrentView();


    SystemMediaTransportControls systemControls;
    MediaElement musicPlayer = new MediaElement();


    public listView()
    {

        this.InitializeComponent();
        makeSongList();

        // Per usare il tasto back
        HardwareButtons.BackPressed += HardwareButtons_BackPressed;

        // Hook up app to system transport controls.
        systemControls = SystemMediaTransportControls.GetForCurrentView();
        systemControls.ButtonPressed += SystemControls_ButtonPressed;

        // Register to handle the following system transpot control buttons.
        systemControls.IsEnabled = true;
        systemControls.IsPlayEnabled = true;
        systemControls.IsPauseEnabled = true;
        systemControls.IsNextEnabled = true;
        systemControls.IsPreviousEnabled = true;

        musicPlayer.AudioCategory = AudioCategory.BackgroundCapableMedia;




    }


    void MusicPlayer_CurrentStateChanged(object sender, RoutedEventArgs e)
    {
        // gestisce l'evento CurrentStateChanged di MediaElement e
        // aggiorna la proprietà PlaybackStatus di SystemMediaTransportControls.

        switch (musicPlayer.CurrentState)
        {
            case MediaElementState.Playing:
                systemControls.PlaybackStatus = MediaPlaybackStatus.Playing;
                break;
            case MediaElementState.Paused:
                systemControls.PlaybackStatus = MediaPlaybackStatus.Paused;
                break;
            case MediaElementState.Stopped:
                systemControls.PlaybackStatus = MediaPlaybackStatus.Stopped;
                break;
            case MediaElementState.Closed:
                systemControls.PlaybackStatus = MediaPlaybackStatus.Closed;
                break;
            default:
                break;
        }
    }

    async private void UpdateSongInfo()
    {
        // Get the updater.
        SystemMediaTransportControlsDisplayUpdater updater = systemControls.DisplayUpdater;

        // Get the music file and pass it to CopyFromFileAsync to extract the metadata
        // and thumbnail. StorageFile is defined in Windows.Storage
        StorageFile musicFile =
            await StorageFile.GetFileFromApplicationUriAsync(new Uri(currentPath));

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

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

    void MusicPlayer_MediaOpened(object sender, RoutedEventArgs e)
    {
        UpdateSongInfo();
    }


    void SystemControls_ButtonPressed(SystemMediaTransportControls sender,
                                      SystemMediaTransportControlsButtonPressedEventArgs args)
    {
        switch (args.Button)
        {
            case SystemMediaTransportControlsButton.Play:
                PlayMedia();
                break;
            case SystemMediaTransportControlsButton.Pause:
                PauseMedia();
                break;
            default:
                break;
        }
    }

    async void PlayMedia()
    {
        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            musicPlayer.Play();
        });
    }

    async void PauseMedia()
    {
        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            musicPlayer.Pause();
        });
    }

Answer 1

Решено с этим!!!!

http://mark.mymonster.nl/2014/05

Я застрял и прочитал тысячи страниц, но этот пример действительно прост и понятен!

Основная проблема состояла в том, чтобы создать компонент времени выполнения Windows и следовать типичной реализации Istance Run для backgroundMediaPlayer с его обработчиками.

 using System;
using System.Diagnostics;
using Windows.ApplicationModel.Background;
using Windows.Foundation.Collections;
using Windows.Media;
using Windows.Media.Playback;

namespace PLAYER
{
    public sealed class BackgroundTask : IBackgroundTask
    {
        private string Artista { get; set; }
        private string Titolo { get; set; }
        private BackgroundTaskDeferral _deferral;
        private SystemMediaTransportControls _systemMediaTransportControl;

        public void Run(IBackgroundTaskInstance taskInstance)
        {
            _systemMediaTransportControl = SystemMediaTransportControls.GetForCurrentView();
            _systemMediaTransportControl.IsEnabled = true;

            BackgroundMediaPlayer.MessageReceivedFromForeground += MessageReceivedFromForeground;
            BackgroundMediaPlayer.Current.CurrentStateChanged += BackgroundMediaPlayerCurrentStateChanged;

            // Associate a cancellation and completed handlers with the background task.
            taskInstance.Canceled += OnCanceled;
            taskInstance.Task.Completed += Taskcompleted;

            _deferral = taskInstance.GetDeferral();
        }

        private void MessageReceivedFromForeground(object sender, MediaPlayerDataReceivedEventArgs e)
        {
            ValueSet valueSet = e.Data;
            foreach (string key in valueSet.Keys)
            {
                switch (key)
                {

                    case "Title":
                        Titolo = valueSet[key].ToString();


                        break;
                    case "Artist":
                        Artista = valueSet[key].ToString();

                        break;
                    case "Play":
                        Debug.WriteLine("Starting Playback");
                        Play(valueSet[key].ToString());
                        break;



                }

            }
        }

        private void Play(string toPlay)
        {
            MediaPlayer mediaPlayer = BackgroundMediaPlayer.Current;
            mediaPlayer.AutoPlay = true;
            mediaPlayer.SetUriSource(new Uri(toPlay));
            _systemMediaTransportControl.ButtonPressed += MediaTransportControlButtonPressed;
            _systemMediaTransportControl.IsPauseEnabled = true;
            _systemMediaTransportControl.IsPlayEnabled = true;
            _systemMediaTransportControl.IsNextEnabled = true;
            _systemMediaTransportControl.IsPreviousEnabled = true;
            _systemMediaTransportControl.DisplayUpdater.Type = MediaPlaybackType.Music;
            _systemMediaTransportControl.DisplayUpdater.MusicProperties.Artist = Artista;
            _systemMediaTransportControl.DisplayUpdater.MusicProperties.Title = Titolo;

            _systemMediaTransportControl.DisplayUpdater.Update();

        }




        /// <summary>
        ///     The MediaPlayer's state changes, update the Universal Volume Control to reflect the correct state.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void BackgroundMediaPlayerCurrentStateChanged(MediaPlayer sender, object args)
        {
            if (sender.CurrentState == MediaPlayerState.Playing)
            {
                _systemMediaTransportControl.PlaybackStatus = MediaPlaybackStatus.Playing;
            }
            else if (sender.CurrentState == MediaPlayerState.Paused)
            {
                _systemMediaTransportControl.PlaybackStatus = MediaPlaybackStatus.Paused;
            }
        }

        /// <summary>
        ///     Handle the buttons on the Universal Volume Control
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void MediaTransportControlButtonPressed(SystemMediaTransportControls sender,
            SystemMediaTransportControlsButtonPressedEventArgs args)
        {
            switch (args.Button)
            {
                case SystemMediaTransportControlsButton.Play:
                    BackgroundMediaPlayer.Current.Play();
                    break;
                case SystemMediaTransportControlsButton.Pause:
                    BackgroundMediaPlayer.Current.Pause();
                    break;
            }
        }


        private void Taskcompleted(BackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs args)
        {
            BackgroundMediaPlayer.Shutdown();
            _deferral.Complete();
        }

        private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
        {
            // You get some time here to save your state before process and resources are reclaimed
            BackgroundMediaPlayer.Shutdown();
            _deferral.Complete();
        }
    }
}

Answer 2

Вы используете SystemMediaTransportControls, поэтому это должно быть приложение времени выполнения для Windows Phone 8.1.

На самом деле, вы упустили много вещей, которые могут помочь вам реализовать фоновый звук. Например: вы не пытались получить BackgroundTaskDeferral, чтобы поддерживать активную фоновую задачу, а также не использовали BackgroundMediaPlayer для связи с глобальным медиаплеером для управления воспроизведением аудио.

Поэтому я предлагаю сначала пройтись по статье " Обзор: фоновое аудио (приложения Магазина Windows Phone)" и проверить, как реализуется официальный образец (вы можете сосредоточиться в основном на MyBackgroundAudioTask.cs в проекте SampleBackgroundAudioTask).