示例#1
0
        private void processStoredQueuedTransfers()
        {
            List <PodcastEpisodeModel> queuedEpisodes = new List <PodcastEpisodeModel>();

            using (var db = new PodcastSqlModel())
            {
                queuedEpisodes = db.Episodes.Where(ep => (ep.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.Queued ||
                                                          ep.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.WaitingForWiFi ||
                                                          ep.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.WaitingForWifiAndPower)
                                                   ).ToList();

                foreach (PodcastEpisodeModel episode in queuedEpisodes)
                {
                    episode.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Queued;
                    m_episodeDownloadQueue.Enqueue(episode);
                }

                db.SubmitChanges();
            }


            if (m_currentBackgroundTransfer == null && m_episodeDownloadQueue.Count > 0)
            {
                startNextEpisodeDownload();
            }
        }
示例#2
0
        private void saveEpisodeInfoToDB(PodcastEpisodeModel m_currentEpisodeDownload)
        {
            if (m_currentEpisodeDownload == null)
            {
                return;
            }

            using (var db = new PodcastSqlModel())
            {
                PodcastEpisodeModel episode = db.Episodes.First(e => e.EpisodeId == m_currentEpisodeDownload.EpisodeId);
                episode.EpisodeDownloadState = m_currentEpisodeDownload.EpisodeDownloadState;
                episode.EpisodeFile          = m_currentEpisodeDownload.EpisodeFile;
                db.SubmitChanges();
            }
        }
示例#3
0
        internal static PodcastEpisodeModel refreshEpisodeFromAudioAgent(PodcastEpisodeModel episode)
        {
            List <PlaylistItem> playlistItems = null;

            using (var playlistdb = new PlaylistDBContext())
            {
                playlistItems = playlistdb.Playlist.ToList();
            }

            PodcastEpisodeModel e = null;

            using (var db = new PodcastSqlModel())
            {
                e = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == episode.EpisodeId);

                bool deleteListened = false;
                if (playlistItems.Count > 0)
                {
                    deleteListened = db.settings().IsAutoDelete;
                }

                foreach (PlaylistItem i in playlistItems)
                {
                    if (i.EpisodeId != episode.EpisodeId)
                    {
                        continue;
                    }

                    Debug.WriteLine("Updating episode '" + e.EpisodeName + "' playpos to: " + i.SavedPlayPosTick);
                    e.SavedPlayPos = i.SavedPlayPosTick;

                    // Update play state to listened as appropriate.
                    if (e.isListened())
                    {
                        e.markAsListened(deleteListened);
                    }

                    db.SubmitChanges();
                }
            }

            return(e);
        }
        private void updateEpisodeWhenDownloaded(PodcastEpisodeModel episode)
        {
            Debug.WriteLine("Updating episode information for episode when download completed: " + episode.EpisodeName);
            episode.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloaded;

            using (var db = new PodcastSqlModel())
            {
                Debug.WriteLine(" * Downloaded file name: " + episode.EpisodeFile);

                PodcastEpisodeModel e = db.episodeForEpisodeId(episode.EpisodeId);
                e.EpisodeFile          = episode.EpisodeFile;
                e.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloaded;
                e.EpisodePlayState     = PodcastEpisodeModel.EpisodePlayStateEnum.Downloaded;

                db.SubmitChanges();

                PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(e.PodcastSubscription);
            }
        }
        private void MenuItemMarkAsListened_Click(object sender, RoutedEventArgs e)
        {
            PodcastEpisodeModel      podcastEpisode = this.DataContext as PodcastEpisodeModel;
            PodcastSubscriptionModel subscription   = null; // We need this to update the play states for this subscription.

            bool delete = false;

            using (var db = new PodcastSqlModel())
            {
                PodcastEpisodeModel sqlepisode = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == podcastEpisode.EpisodeId);

                subscription = db.Subscriptions.FirstOrDefault(sub => sub.PodcastId == sqlepisode.PodcastId);
                PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(subscription);

                delete = db.settings().IsAutoDelete;

                sqlepisode.SavedPlayPos     = 0;
                sqlepisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Listened;
                db.SubmitChanges();
            }

            podcastEpisode.markAsListened(delete);
        }
        private void MenuItemMarkAsListened_Click(object sender, RoutedEventArgs e)
        {
            PodcastEpisodeModel podcastEpisode = this.DataContext as PodcastEpisodeModel;
            PodcastSubscriptionModel subscription = null; // We need this to update the play states for this subscription.

            bool delete = false;            
            using (var db = new PodcastSqlModel())
            {
                PodcastEpisodeModel sqlepisode = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == podcastEpisode.EpisodeId);
                
                subscription = db.Subscriptions.FirstOrDefault(sub => sub.PodcastId == sqlepisode.PodcastId);
                PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(subscription);

                delete = db.settings().IsAutoDelete;

                sqlepisode.SavedPlayPos = 0;
                sqlepisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Listened;
                db.SubmitChanges();
            }

            podcastEpisode.markAsListened(delete);

        }
        private void PlayStateChanged(object sender, EventArgs e)
        {
            EventHandler handlerStoppedPlaying = null;
            switch (BackgroundAudioPlayer.Instance.PlayerState)
            {
                case PlayState.Playing:
                    PodcastEpisodeModel currentEpisode = updateCurrentlyPlayingEpisode();
                    if (currentEpisode == null)
                    {
                        Debug.WriteLine("Error: No playing episode in DB.");
                        return;
                    }

                    if (CurrentlyPlayingEpisode == null)
                    {
                        CurrentlyPlayingEpisode = currentEpisode;
                    } else if (currentEpisode.EpisodeId != CurrentlyPlayingEpisode.EpisodeId)
                    {
                        CurrentlyPlayingEpisode = currentEpisode;
                        CurrentlyPlayingEpisode.setPlaying();
                    }

                    if (CurrentlyPlayingEpisode.TotalLengthTicks == 0)
                    {
                        CurrentlyPlayingEpisode.TotalLengthTicks = BackgroundAudioPlayer.Instance.Track.Duration.Ticks;
                        using (var db = new PodcastSqlModel())
                        {
                            PodcastEpisodeModel episode = db.episodeForEpisodeId(CurrentlyPlayingEpisode.EpisodeId);
                            if (episode == null)
                            {
                                Debug.WriteLine("Warning: Got NULL episode from DB when trying to update this episode.");
                                return;
                            }

                            episode.TotalLengthTicks = CurrentlyPlayingEpisode.TotalLengthTicks;
                            db.SubmitChanges();

                            PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(episode.PodcastSubscription);
                        }
                    }

                    break;

                case PlayState.Paused:
                    BackgroundAudioPlayer playerPaused = BackgroundAudioPlayer.Instance;
                    if (CurrentlyPlayingEpisode != null)
                    {
                        CurrentlyPlayingEpisode = App.refreshEpisodeFromAudioAgent(CurrentlyPlayingEpisode);
                        CurrentlyPlayingEpisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Paused;
                        using (var db = new PodcastSqlModel())
                        {
                            PodcastEpisodeModel updatedEpisode = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == CurrentlyPlayingEpisode.EpisodeId);
                            updatedEpisode.EpisodePlayState = CurrentlyPlayingEpisode.EpisodePlayState;
                            db.SubmitChanges();
                        }

                        handlerStoppedPlaying = OnPodcastStoppedPlaying;
                        if (handlerStoppedPlaying != null)
                        {
                            OnPodcastStoppedPlaying(this, new EventArgs());
                        }

                    }
                    else
                    {
                        Debug.WriteLine("SHOULD NOT HAPPEND! Cannot save episode state to paused!");
                    }
                    break;

                case PlayState.Stopped:
                case PlayState.Shutdown:
                case PlayState.TrackEnded:
                    if (CurrentlyPlayingEpisode == null)
                    {
                        // We didn't have a track playing.
                        return;
                    }

                    // F**K YOU WINDOWS PHONE!!
                    /**
                     * This is so horrible that I can't find other words to describe how bad the BackgroundAudioPlayer
                     * is in Windows Phone!
                     *
                     * First of all the events are fired totally differently between Windows Phone 7 and Windows Phone 8.
                     * Secondly the events related to when tracks end arae totally wrong and horrible! Let me explain:
                     * - We get here the PlayState.Stopped event when the track ends.
                     * - We get the event here BEFORE the AudioAgent gets any events.
                     * - AudioAgent correctly gets the PlayState.TrackEnded event, but it gets it after we have received the
                     *   event here.
                     * - We NEVER get the the PlayState.TrackEnded event here.
                     * - Which is not the case for Windows Phone 7, because it first fires PlayState.TrackEnded.
                     *
                     * So this code here is a horrible kludge that just guesses that Windows Phone means "track did end"
                     * when the state is stopped and the play position is still 0.
                     *
                     * Johan, when you return from the future to this piece of code, don't even try to change it or "fix it".
                     **/
                    long playpos = 0;
                    if (BackgroundAudioPlayer.Instance.PlayerState == PlayState.TrackEnded)
                    {
                        playpos = CurrentlyPlayingEpisode.TotalLengthTicks;
                    }
                    else if (BackgroundAudioPlayer.Instance.PlayerState == PlayState.Stopped
                      && BackgroundAudioPlayer.Instance.Position.Ticks == 0)
                    {
                        playpos = CurrentlyPlayingEpisode.TotalLengthTicks;
                    }
                    else
                    {
                        try
                        {
                            playpos = BackgroundAudioPlayer.Instance.Position.Ticks;
                        }
                        catch (Exception)
                        {
                            Debug.WriteLine("Warning: Player didn't return us a play pos!");
                        }
                    }

                    CurrentlyPlayingEpisode.SavedPlayPos = playpos;
                    CurrentlyPlayingEpisode.setNoPlaying();

                    using (var db = new PodcastSqlModel())
                    {
                        PodcastEpisodeModel savingEpisode = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == CurrentlyPlayingEpisode.EpisodeId);
                        if (savingEpisode != null)
                        {
                            savingEpisode.SavedPlayPos = CurrentlyPlayingEpisode.SavedPlayPos;
                            // Update play state to listened as appropriate.
                            if (savingEpisode.isListened())
                            {
                                savingEpisode.markAsListened(db.settings().IsAutoDelete);
                                removeFromPlayqueue(savingEpisode);
                            }
                            else
                            {
                                savingEpisode.EpisodePlayState = CurrentlyPlayingEpisode.EpisodePlayState;
                            }
                            db.SubmitChanges();

                            PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(savingEpisode.PodcastSubscription);
                        }
                    }

                    PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(CurrentlyPlayingEpisode.PodcastSubscriptionInstance);
                    handlerStoppedPlaying = OnPodcastStoppedPlaying;
                    if (handlerStoppedPlaying != null)
                    {
                        OnPodcastStoppedPlaying(this, new EventArgs());
                    }

                    // Cleanup
                    CurrentlyPlayingEpisode = null;
                    break;

                case PlayState.TrackReady:
                    break;

                case PlayState.Unknown:
                    // Unknown? WTF.
                    break;

            }

            App.mainViewModels.PlayQueue = new System.Collections.ObjectModel.ObservableCollection<PlaylistItem>();

            if (CurrentlyPlayingEpisode != null)
            {
                PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(CurrentlyPlayingEpisode.PodcastSubscriptionInstance);
            }
        }
        public void play(PodcastEpisodeModel episode, bool startedFromPlayQueue = false)
        {
            if (episode == null)
            {
                Debug.WriteLine("Warning: Trying to play a NULL episode.");
                return;
            }

            Debug.WriteLine("Starting playback for episode: ");
            Debug.WriteLine(" Name: " + episode.EpisodeName);
            Debug.WriteLine(" File: " + episode.EpisodeFile);
            Debug.WriteLine(" Location: " + episode.EpisodeDownloadUri);

            // We have another episode currently playing, and we switch the episode that we are playing.
            if (CurrentlyPlayingEpisode != null
                && (episode.EpisodeId != CurrentlyPlayingEpisode.EpisodeId))
            {
                CurrentlyPlayingEpisode.setNoPlaying();

                try
                {
                    CurrentlyPlayingEpisode.SavedPlayPos = BackgroundAudioPlayer.Instance.Position.Ticks;
                }
                catch (Exception)
                {
                    Debug.WriteLine("Could not set saved play pos; not available.");
                    CurrentlyPlayingEpisode.SavedPlayPos = 0;
                }

                using (var db = new PodcastSqlModel())
                {
                    PodcastEpisodeModel savingEpisode = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == CurrentlyPlayingEpisode.EpisodeId);
                    savingEpisode.SavedPlayPos = CurrentlyPlayingEpisode.SavedPlayPos;
                    db.SubmitChanges();
                }
            }

            if (startedFromPlayQueue)
            {
                if (BackgroundAudioPlayer.Instance.PlayerState != PlayState.Paused
                    || (CurrentlyPlayingEpisode != null
                        && CurrentlyPlayingEpisode.EpisodeId != episode.EpisodeId))
                {
                    CurrentlyPlayingEpisode = episode;
                }
            }
            else
            {
                CurrentlyPlayingEpisode = episode;

                // Clear play queue (yes) when we start playback from episode listing.
                // And we clear the queue after the current episode is being set, so that we don't delete the currently
                // playing one.
                clearPlayQueue();
            }

            // Play locally from a downloaded file.
            if (CurrentlyPlayingEpisode != null
                && CurrentlyPlayingEpisode.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloaded)
            {
                PodcastPlayerControl player = PodcastPlayerControl.getIntance();
                CurrentlyPlayingEpisode.setPlaying();
                CurrentlyPlayingEpisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Playing;
                player.playEpisode(CurrentlyPlayingEpisode);
            }
            else
            {
                // Stream it if not downloaded.
                if (isAudioPodcast(CurrentlyPlayingEpisode))
                {
                    CurrentlyPlayingEpisode.setPlaying();
                    audioStreaming(CurrentlyPlayingEpisode);
                    CurrentlyPlayingEpisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Streaming;
                }
                else
                {
                    PodcastPlayerControl player = PodcastPlayerControl.getIntance();
                    player.StopPlayback();
                    videoStreaming(episode);
                    CurrentlyPlayingEpisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Streaming;
                }
            }

            // Always open the player view.
            var handler = OnOpenPodcastPlayer;
            if (handler != null)
            {
                OnOpenPodcastPlayer(this, new EventArgs());
            }

            var handlerStartedPlaying = OnPodcastStartedPlaying;
            if (handlerStartedPlaying != null)
            {
                if (isAudioPodcast(episode))
                {
                    OnPodcastStartedPlaying(this, new EventArgs());
                }
            }

            App.mainViewModels.PlayQueue = new System.Collections.ObjectModel.ObservableCollection<PlaylistItem>(); // Notify playlist changed.
        }
        private void updateEpisodeWhenDownloaded(PodcastEpisodeModel episode)
        {
            Debug.WriteLine("Updating episode information for episode when download completed: " + episode.EpisodeName);
            episode.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloaded;

            using (var db = new PodcastSqlModel())
            {
                Debug.WriteLine(" * Downloaded file name: " + episode.EpisodeFile);

                PodcastEpisodeModel e = db.episodeForEpisodeId(episode.EpisodeId);
                e.EpisodeFile = episode.EpisodeFile;
                e.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloaded;
                e.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Downloaded;

                db.SubmitChanges();

                PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(e.PodcastSubscription);
            }
        }
        private void processStoredQueuedTransfers()
        {
            List<PodcastEpisodeModel> queuedEpisodes = new List<PodcastEpisodeModel>();
            using (var db = new PodcastSqlModel())
            {
                queuedEpisodes = db.Episodes.Where(ep => (ep.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.Queued
                                                          || ep.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.WaitingForWiFi
                                                          || ep.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.WaitingForWifiAndPower)
                                                  ).ToList();

                foreach (PodcastEpisodeModel episode in queuedEpisodes)
                {
                    episode.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Queued;
                    m_episodeDownloadQueue.Enqueue(episode);
                }

                db.SubmitChanges();
            }

            if (m_currentBackgroundTransfer == null && m_episodeDownloadQueue.Count > 0)
            {
                startNextEpisodeDownload();
            }
        }
        private void saveEpisodeInfoToDB(PodcastEpisodeModel m_currentEpisodeDownload)
        {
            if (m_currentEpisodeDownload == null)
            {
                return;
            }

            using (var db = new PodcastSqlModel())
            {
                PodcastEpisodeModel episode = db.Episodes.First(e => e.EpisodeId == m_currentEpisodeDownload.EpisodeId);
                episode.EpisodeDownloadState = m_currentEpisodeDownload.EpisodeDownloadState;
                episode.EpisodeFile = m_currentEpisodeDownload.EpisodeFile;
                db.SubmitChanges();
            }
        }
示例#12
0
        private void PlayStateChanged(object sender, EventArgs e)
        {
            EventHandler handlerStoppedPlaying = null;

            switch (BackgroundAudioPlayer.Instance.PlayerState)
            {
            case PlayState.Playing:
                PodcastEpisodeModel currentEpisode = updateCurrentlyPlayingEpisode();
                if (currentEpisode == null)
                {
                    Debug.WriteLine("Error: No playing episode in DB.");
                    return;
                }

                if (CurrentlyPlayingEpisode == null)
                {
                    CurrentlyPlayingEpisode = currentEpisode;
                }
                else if (currentEpisode.EpisodeId != CurrentlyPlayingEpisode.EpisodeId)
                {
                    CurrentlyPlayingEpisode = currentEpisode;
                }

                if (CurrentlyPlayingEpisode.TotalLengthTicks == 0)
                {
                    CurrentlyPlayingEpisode.StoreProperty <long>("TotalLengthTicks", BackgroundAudioPlayer.Instance.Track.Duration.Ticks);
                    PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(CurrentlyPlayingEpisode.getSubscriptionModel());
                }
                break;

            case PlayState.Paused:
                BackgroundAudioPlayer playerPaused = BackgroundAudioPlayer.Instance;
                if (CurrentlyPlayingEpisode != null)
                {
                    CurrentlyPlayingEpisode = App.refreshEpisodeFromAudioAgent(CurrentlyPlayingEpisode);
                    CurrentlyPlayingEpisode.StoreProperty <PodcastEpisodeModel.EpisodePlayStateEnum>("EpisodePlayState", PodcastEpisodeModel.EpisodePlayStateEnum.Paused);
                }
                else
                {
                    Debug.WriteLine("SHOULD NOT HAPPEND! Cannot save episode state to paused!");
                }
                break;

            case PlayState.Stopped:
            case PlayState.Shutdown:
            case PlayState.TrackEnded:
                if (CurrentlyPlayingEpisode == null)
                {
                    // We didn't have a track playing.
                    return;
                }

                // F**K YOU WINDOWS PHONE!!

                /**
                 * This is so horrible that I can't find other words to describe how bad the BackgroundAudioPlayer
                 * is in Windows Phone!
                 *
                 * First of all the events are fired totally differently between Windows Phone 7 and Windows Phone 8.
                 * Secondly the events related to when tracks end arae totally wrong and horrible! Let me explain:
                 * - We get here the PlayState.Stopped event when the track ends.
                 * - We get the event here BEFORE the AudioAgent gets any events.
                 * - AudioAgent correctly gets the PlayState.TrackEnded event, but it gets it after we have received the
                 *   event here.
                 * - We NEVER get the the PlayState.TrackEnded event here.
                 * - Which is not the case for Windows Phone 7, because it first fires PlayState.TrackEnded.
                 *
                 * So this code here is a horrible kludge that just guesses that Windows Phone means "track did end"
                 * when the state is stopped and the play position is still 0.
                 *
                 * Johan, when you return from the future to this piece of code, don't even try to change it or "fix it".
                 **/
                long playpos = 0;
                if (BackgroundAudioPlayer.Instance.PlayerState == PlayState.TrackEnded)
                {
                    playpos = CurrentlyPlayingEpisode.TotalLengthTicks;
                }
                else if (BackgroundAudioPlayer.Instance.PlayerState == PlayState.Stopped &&
                         BackgroundAudioPlayer.Instance.Position.Ticks == 0)
                {
                    playpos = CurrentlyPlayingEpisode.TotalLengthTicks;
                }
                else
                {
                    try
                    {
                        playpos = BackgroundAudioPlayer.Instance.Position.Ticks;
                    }
                    catch (Exception)
                    {
                        Debug.WriteLine("Warning: Player didn't return us a play pos!");
                    }
                }

                CurrentlyPlayingEpisode.SavedPlayPos = playpos;
                CurrentlyPlayingEpisode.setNoPlaying();

                using (var db = new PodcastSqlModel())
                {
                    PodcastEpisodeModel savingEpisode = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == CurrentlyPlayingEpisode.EpisodeId);
                    if (savingEpisode != null)
                    {
                        savingEpisode.SavedPlayPos = CurrentlyPlayingEpisode.SavedPlayPos;
                        // Update play state to listened as appropriate.
                        if (savingEpisode.isListened())
                        {
                            savingEpisode.markAsListened(db.settings().IsAutoDelete);
                            removeFromPlayqueue(savingEpisode);
                        }
                        else
                        {
                            savingEpisode.EpisodePlayState = CurrentlyPlayingEpisode.EpisodePlayState;
                        }
                        db.SubmitChanges();

                        PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(savingEpisode.PodcastSubscription);
                    }
                }

                PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(CurrentlyPlayingEpisode.getSubscriptionModel());
                handlerStoppedPlaying = OnPodcastStoppedPlaying;
                if (handlerStoppedPlaying != null)
                {
                    OnPodcastStoppedPlaying(this, new EventArgs());
                }

                // Cleanup
                CurrentlyPlayingEpisode = null;
                break;

            case PlayState.TrackReady:
                break;

            case PlayState.Unknown:
                // Unknown? WTF.
                break;
            }

            App.mainViewModels.PlayQueue = new System.Collections.ObjectModel.ObservableCollection <PlaylistItem>();

            if (CurrentlyPlayingEpisode != null)
            {
                PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(CurrentlyPlayingEpisode.PodcastSubscriptionInstance);
            }
        }
示例#13
0
        public static void refreshEpisodesFromAudioAgent()
        {
            Debug.WriteLine("Refreshing episode information that has been updated from AudioPlayer.");

            using (var playlistdb = new PlaylistDBContext())
            {
                int playlistItemsCount            = 0;
                int listenedItemsCount            = 0;
                List <PlaylistItem> playlistItems = playlistdb.Playlist.ToList();

                playlistItemsCount = playlistItems.Count;
                using (var db = new PodcastSqlModel())
                {
                    bool deleteListened = false;
                    if (playlistItems.Count > 0)
                    {
                        deleteListened = db.settings().IsAutoDelete;
                    }

                    foreach (PlaylistItem i in playlistItems)
                    {
                        PodcastEpisodeModel e = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == i.EpisodeId);
                        if (e == null)
                        {
                            Debug.WriteLine("Warning: Could not fetch episode with ID: " + i.EpisodeId);
                            continue;
                        }

                        if (i.SavedPlayPosTick > 0)
                        {
                            Debug.WriteLine("Updating episode '" + e.EpisodeName + "' playpos to: " + i.SavedPlayPosTick);
                            e.SavedPlayPos = i.SavedPlayPosTick;

                            try
                            {
                                db.SubmitChanges();
                            }
                            catch (ChangeConflictException)
                            {
                                Debug.WriteLine("ChangeConflictException: Could not submit changes");
                            }

                            // Update play state to listened as appropriate.
                            if (e.isListened())
                            {
                                e.markAsListened(deleteListened);
                                PodcastPlaybackManager.getInstance().removeFromPlayqueue(e);
                                listenedItemsCount++;
                            }

                            e.PodcastSubscription.reloadPartiallyPlayedEpisodes();
                            e.PodcastSubscription.reloadUnplayedPlayedEpisodes();
                        }
                    }
                }

                // If all items in the play queue were listened, then we shouldn't show an episodep laying anymore.
                if (playlistItemsCount == listenedItemsCount)
                {
                    PodcastPlaybackManager.getInstance().CurrentlyPlayingEpisode = null;
                }
            }
        }
示例#14
0
        internal static PodcastEpisodeModel refreshEpisodeFromAudioAgent(PodcastEpisodeModel episode)
        {
            List<PlaylistItem> playlistItems = null;
            using (var playlistdb = new PlaylistDBContext())
            {
                playlistItems = playlistdb.Playlist.ToList();
            }

            PodcastEpisodeModel e = null;
            using (var db = new PodcastSqlModel())
            {
                e = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == episode.EpisodeId);

                bool deleteListened = false;
                if (playlistItems.Count > 0)
                {
                    deleteListened = db.settings().IsAutoDelete;
                }

                foreach (PlaylistItem i in playlistItems)
                {
                    if (i.EpisodeId != episode.EpisodeId)
                    {
                        continue;
                    }

                    Debug.WriteLine("Updating episode '" + e.EpisodeName + "' playpos to: " + i.SavedPlayPosTick);
                    e.SavedPlayPos = i.SavedPlayPosTick;

                    // Update play state to listened as appropriate.
                    if (e.isListened())
                    {
                        e.markAsListened(deleteListened);
                    }

                    db.SubmitChanges();
                }
            }

            return e;
        }
示例#15
0
        public static void refreshEpisodesFromAudioAgent()
        {
            Debug.WriteLine("Refreshing episode information that has been updated from AudioPlayer.");

            using (var playlistdb = new PlaylistDBContext())
            {
                int playlistItemsCount = 0;
                int listenedItemsCount = 0;
                List<PlaylistItem> playlistItems = playlistdb.Playlist.ToList();

                playlistItemsCount = playlistItems.Count;
                using (var db = new PodcastSqlModel())
                {
                    bool deleteListened = false;
                    if (playlistItems.Count > 0)
                    {
                        deleteListened = db.settings().IsAutoDelete;
                    }

                    foreach (PlaylistItem i in playlistItems)
                    {
                        PodcastEpisodeModel e = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == i.EpisodeId);
                        if (e == null)
                        {
                            Debug.WriteLine("Warning: Could not fetch episode with ID: " + i.EpisodeId);
                            continue;
                        }

                        if (i.SavedPlayPosTick > 0)
                        {
                            Debug.WriteLine("Updating episode '" + e.EpisodeName + "' playpos to: " + i.SavedPlayPosTick);
                            e.SavedPlayPos = i.SavedPlayPosTick;

                            try
                            {
                                db.SubmitChanges();
                            }
                            catch (ChangeConflictException)
                            {
                                Debug.WriteLine("ChangeConflictException: Could not submit changes");
                            }

                            // Update play state to listened as appropriate.
                            if (e.isListened())
                            {
                                e.markAsListened(deleteListened);
                                PodcastPlaybackManager.getInstance().removeFromPlayqueue(e);
                                listenedItemsCount++;
                            }

                            e.PodcastSubscription.reloadPartiallyPlayedEpisodes();
                            e.PodcastSubscription.reloadUnplayedPlayedEpisodes();
                        }
                    }
                }

                // If all items in the play queue were listened, then we shouldn't show an episodep laying anymore.
                if (playlistItemsCount == listenedItemsCount)
                {
                    PodcastPlaybackManager.getInstance().CurrentlyPlayingEpisode = null;
                }
            }
        }
示例#16
0
        public void play(PodcastEpisodeModel episode, bool startedFromPlayQueue = false)
        {
            if (episode == null)
            {
                Debug.WriteLine("Warning: Trying to play a NULL episode.");
                return;
            }

            Debug.WriteLine("Starting playback for episode: ");
            Debug.WriteLine(" Name: " + episode.EpisodeName);
            Debug.WriteLine(" File: " + episode.EpisodeFile);
            Debug.WriteLine(" Location: " + episode.EpisodeDownloadUri);

            // We have another episode currently playing, and we switch the episode that we are playing.
            if (CurrentlyPlayingEpisode != null &&
                (episode.EpisodeId != CurrentlyPlayingEpisode.EpisodeId))
            {
                CurrentlyPlayingEpisode.setNoPlaying();

                try
                {
                    CurrentlyPlayingEpisode.SavedPlayPos = BackgroundAudioPlayer.Instance.Position.Ticks;
                }
                catch (Exception)
                {
                    Debug.WriteLine("Could not set saved play pos; not available.");
                    CurrentlyPlayingEpisode.SavedPlayPos = 0;
                }

                using (var db = new PodcastSqlModel())
                {
                    PodcastEpisodeModel savingEpisode = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == CurrentlyPlayingEpisode.EpisodeId);
                    savingEpisode.SavedPlayPos = CurrentlyPlayingEpisode.SavedPlayPos;
                    db.SubmitChanges();
                }
            }

            if (startedFromPlayQueue)
            {
                if (BackgroundAudioPlayer.Instance.PlayerState != PlayState.Paused ||
                    (CurrentlyPlayingEpisode != null &&
                     CurrentlyPlayingEpisode.EpisodeId != episode.EpisodeId))
                {
                    CurrentlyPlayingEpisode = episode;
                }
            }
            else
            {
                CurrentlyPlayingEpisode = episode;

                // Clear play queue (yes) when we start playback from episode listing.
                // And we clear the queue after the current episode is being set, so that we don't delete the currently
                // playing one.
                clearPlayQueue();
            }

            // Play locally from a downloaded file.
            if (CurrentlyPlayingEpisode != null &&
                CurrentlyPlayingEpisode.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloaded)
            {
                PodcastPlayerControl player = PodcastPlayerControl.getIntance();
                CurrentlyPlayingEpisode.setPlaying();
                CurrentlyPlayingEpisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Playing;
                player.playEpisode(CurrentlyPlayingEpisode);
            }
            else
            {
                // Stream it if not downloaded.
                if (isAudioPodcast(CurrentlyPlayingEpisode))
                {
                    CurrentlyPlayingEpisode.setPlaying();
                    audioStreaming(CurrentlyPlayingEpisode);
                    CurrentlyPlayingEpisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Streaming;
                }
                else
                {
                    PodcastPlayerControl player = PodcastPlayerControl.getIntance();
                    player.StopPlayback();
                    videoStreaming(episode);
                    CurrentlyPlayingEpisode.EpisodePlayState = PodcastEpisodeModel.EpisodePlayStateEnum.Streaming;
                }
            }

            // Always open the player view.
            var handler = OnOpenPodcastPlayer;

            if (handler != null)
            {
                OnOpenPodcastPlayer(this, new EventArgs());
            }

            var handlerStartedPlaying = OnPodcastStartedPlaying;

            if (handlerStartedPlaying != null)
            {
                if (isAudioPodcast(episode))
                {
                    OnPodcastStartedPlaying(this, new EventArgs());
                }
            }

            App.mainViewModels.PlayQueue = new System.Collections.ObjectModel.ObservableCollection <PlaylistItem>(); // Notify playlist changed.
        }