private void startNewPlayback(PodcastEpisodeModel episodeModel, bool streaming) { m_currentPlayerEpisode = episodeModel; setupPlayerUIContent(episodeModel); updatePrimary(episodeModel); if (episodeModel.SavedPlayPos > 0) { bool alwaysContinuePlayback = false; using (var db = new PodcastSqlModel()) { alwaysContinuePlayback = db.settings().IsAutomaticContinuedPlayback; } if (alwaysContinuePlayback) { startPlayback(episodeModel, new TimeSpan(episodeModel.SavedPlayPos), streaming); } else { askForContinueEpisodePlaying(episodeModel, streaming); } } else { startPlayback(episodeModel, TimeSpan.Zero, streaming); } }
public void exportSubscriptions() { List <PodcastSubscriptionModel> subscriptions = App.mainViewModels.PodcastSubscriptions.ToList(); if (subscriptions.Count == 0) { MessageBox.Show("No subscriptions to export."); return; } using (var db = new PodcastSqlModel()) { if (db.settings().SelectedExportIndex == (int)SettingsModel.ExportMode.ExportToSkyDrive) { if (liveConnect == null) { loginUserToSkyDrive(); } else { DoOPMLExport(); } } else if (db.settings().SelectedExportIndex == (int)SettingsModel.ExportMode.ExportViaEmail) { DoOPMLExport(); } } }
internal void SetupNowPlayingView() { this.DataContext = null; m_playbackManager = PodcastPlaybackManager.getInstance(); if (m_playbackManager.CurrentlyPlayingEpisode != null) { this.Visibility = Visibility.Visible; } else { this.Visibility = Visibility.Collapsed; return; } if (m_currentlyPlayingEpisodeId < 0 || m_playbackManager.CurrentlyPlayingEpisode.EpisodeId != m_currentlyPlayingEpisodeId) { m_currentlyPlayingEpisodeId = m_playbackManager.CurrentlyPlayingEpisode.EpisodeId; using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel s = db.Subscriptions.First(sub => sub.PodcastId == m_playbackManager.CurrentlyPlayingEpisode.PodcastId); m_podcastLogo = getLogoForSubscription(s); } } this.DataContext = m_playbackManager.CurrentlyPlayingEpisode; this.PodcastLogo.Source = m_podcastLogo; }
public void startDefaultBehaviorPlayback() { using (PodcastSqlModel db = new PodcastSqlModel()) { try { PodcastEpisodeModel latestPlayed = db.Episodes.Where(ep => (ep.LastPlayed.HasValue == true && ep.LastPlayed.Value.Year > 2013)).OrderByDescending(ep => ep.LastPlayed).FirstOrDefault(); if (latestPlayed != null) { App.showNotificationToast("Playing recently played episode."); play(latestPlayed); return; } } catch (InvalidOperationException) { Debug.WriteLine("Could not find a suitable latest episode played."); } // Did not find a suitable episode that was previously played, so we have to start a "new" playback. // This playback is the latest published episode. PodcastEpisodeModel newestEpisode = db.Episodes.OrderByDescending(ep => ep.EpisodePublished).FirstOrDefault(); if (newestEpisode != null) { App.showNotificationToast("Playing newest episode."); play(newestEpisode); } else { Debug.WriteLine("Uups, cannot find a newest episode to play."); } } }
public PodcastEpisodeModel updateCurrentlyPlayingEpisode() { PlaylistItem plItem = null; using (var playlistDb = new PlaylistDBContext()) { if (playlistDb.Playlist.Count() == 0) { return(null); } plItem = playlistDb.Playlist.Where(item => item.IsCurrent).FirstOrDefault(); } if (plItem != null) { using (var db = new PodcastSqlModel()) { PodcastEpisodeModel currentEpisode = db.Episodes.Where(ep => ep.EpisodeId == plItem.EpisodeId).FirstOrDefault(); CurrentlyPlayingEpisode = currentEpisode; return(currentEpisode); } } return(null); }
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 AudioTrack getAudioTrackForEpisode(PodcastEpisodeModel currentEpisode) { if (currentEpisode == null || String.IsNullOrEmpty(currentEpisode.EpisodeFile)) { return(null); } Uri episodeLocation; try { episodeLocation = new Uri(currentEpisode.EpisodeFile, UriKind.Relative); } catch (Exception) { return(null); } using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel sub = db.Subscriptions.First(s => s.PodcastId == currentEpisode.PodcastId); return(new AudioTrack(episodeLocation, currentEpisode.EpisodeName, sub.PodcastName, "", new Uri(sub.PodcastLogoLocalLocation, UriKind.Relative))); } }
public void removeFromPlayqueue(int itemId) { using (var db = new PlaylistDBContext()) { PlaylistItem itemToRemove = db.Playlist.FirstOrDefault(item => item.ItemId == itemId); if (itemToRemove != null) { PodcastEpisodeModel episode = null; using (var episodeDb = new PodcastSqlModel()) { episode = episodeDb.episodeForPlaylistItem(itemToRemove); if (episode != null) { if (episode.isListened()) { episode.markAsListened(episodeDb.settings().IsAutoDelete); } } else { Debug.WriteLine("Warning: Could not get episode for item id: " + itemToRemove.ItemId); } } db.Playlist.DeleteOnSubmit(itemToRemove); db.SubmitChanges(); App.mainViewModels.PlayQueue = new ObservableCollection <PlaylistItem>(); } } }
private AudioTrack getAudioStreamForEpisode(PodcastEpisodeModel episode) { if (episode == null || String.IsNullOrEmpty(episode.EpisodeDownloadUri)) { return(null); } Uri episodeLocation; try { episodeLocation = new Uri(episode.EpisodeDownloadUri, UriKind.Absolute); } catch (Exception) { return(null); } using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel sub = db.Subscriptions.First(s => s.PodcastId == episode.PodcastId); return(new AudioTrack(episodeLocation, episode.EpisodeName, sub.PodcastName, "", new Uri(sub.PodcastLogoLocalLocation, UriKind.Relative))); } }
internal void SetupNowPlayingView() { PodcastPlaybackManager pm = PodcastPlaybackManager.getInstance(); if (pm.CurrentlyPlayingEpisode != null) { this.Visibility = Visibility.Visible; } else { this.Visibility = Visibility.Collapsed; return; } if (m_currentlyPlayingEpisodeId < 0 || pm.CurrentlyPlayingEpisode.EpisodeId != m_currentlyPlayingEpisodeId) { m_currentlyPlayingEpisodeId = pm.CurrentlyPlayingEpisode.EpisodeId; using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel s = db.Subscriptions.First(sub => sub.PodcastId == pm.CurrentlyPlayingEpisode.PodcastId); m_podcastLogo = getLogoForSubscription(s); } } this.DataContext = pm.CurrentlyPlayingEpisode; this.PodcastLogo.Source = m_podcastLogo; }
public void playPlaylistItem(int tappedPlaylistItemId) { int episodeId = -1; using (var db = new PlaylistDBContext()) { if (db.Playlist.Count() < 1) { return; } episodeId = (int)db.Playlist.Where(item => item.ItemId == tappedPlaylistItemId).Select(item => item.EpisodeId).First(); } PodcastEpisodeModel episode = null; using (var db = new PodcastSqlModel()) { episode = db.Episodes.First(ep => ep.EpisodeId == episodeId); } if (episode != null) { play(episode, true); } else { Debug.WriteLine("Warning: Could not play episode: " + episodeId); } }
private PodcastSubscriptionsManager() { m_podcastsSqlModel = PodcastSqlModel.getInstance(); m_random = new Random(); // Hook a callback method to the signal that we emit when the subscription has been added. // This way we can continue the synchronous execution. this.OnPodcastChannelFinished += new SubscriptionManagerHandler(PodcastSubscriptionsManager_OnPodcastAddedFinished); }
public void play(PlaylistItem playlistItem) { using (PodcastSqlModel db = new PodcastSqlModel()) { PodcastEpisodeModel episode = db.Episodes.FirstOrDefault(ep => ep.EpisodeId == playlistItem.EpisodeId); if (episode != null) { play(episode); } } }
void deleteSubscriptionFromDB(object sender, DoWorkEventArgs e) { PodcastSubscriptionModel podcastModel = e.Argument as PodcastSubscriptionModel; using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel dbSubscription = db.Subscriptions.First(s => s.PodcastId == podcastModel.PodcastId); dbSubscription.cleanupForDeletion(); db.deleteSubscription(dbSubscription); } e.Result = podcastModel; }
private void PlayOrderChanged(object sender, SelectionChangedEventArgs e) { ListPickerItem selectedItem = (sender as ListPicker).SelectedItem as ListPickerItem; if (selectedItem == null) { return; } using (var db = new PodcastSqlModel()) { PodcastPlaybackManager.getInstance().sortPlaylist(db.settings().PlaylistSortOrder); } }
// Code to execute when the application is launching (eg, from Start) // This code will not execute when the application is reactivated private void Application_Launching(object sender, LaunchingEventArgs e) { // IsolatedStorageExplorer.Explorer.Start("192.168.0.6"); using (var db = new PodcastSqlModel()) { db.createDB(); } // Updates episodes from the audio agent. refreshEpisodesFromAudioAgent(); // Diagnostics ApplicationUsageHelper.Init(App.AppVersion); }
public void sortPlaylist(int sortOrder) { using (var playlistDB = new PlaylistDBContext()) { if (playlistDB.Playlist.Count() <= 1) { return; } PodcastSqlModel sqlContext = new PodcastSqlModel(); IEnumerable <PlaylistItem> newSortOrderQuery = null; List <PlaylistItem> newSortOrder = new List <PlaylistItem>(); var query = playlistDB.Playlist.AsEnumerable().Join(episodes(sqlContext), item => item.EpisodeId, episode => episode.EpisodeId, (item, episode) => new { PlaylistItem = item, PodcastEpisodeModel = episode }); switch (sortOrder) { // Oldest first case 0: newSortOrderQuery = query.OrderBy(newPlaylistItem => newPlaylistItem.PodcastEpisodeModel.EpisodePublished) .Select(newPlaylistItem => newPlaylistItem.PlaylistItem).AsEnumerable(); break; // Newest first. case 1: newSortOrderQuery = query.OrderByDescending(newPlaylistItem => newPlaylistItem.PodcastEpisodeModel.EpisodePublished) .Select(newPlaylistItem => newPlaylistItem.PlaylistItem).AsEnumerable(); break; } int i = 0; foreach (PlaylistItem item in newSortOrderQuery) { PlaylistItem newItem = item; newItem.OrderNumber = i++; newSortOrder.Add(newItem); } playlistDB.Playlist.DeleteAllOnSubmit(playlistDB.Playlist); playlistDB.Playlist.InsertAllOnSubmit(newSortOrder); playlistDB.SubmitChanges(); } Deployment.Current.Dispatcher.BeginInvoke(() => { App.mainViewModels.PlayQueue = new ObservableCollection <PlaylistItem>(); }); }
private void MenuItemDelete_Click(object sender, RoutedEventArgs e) { PodcastEpisodeModel podcastEpisode = (sender as MenuItem).DataContext as PodcastEpisodeModel; podcastEpisode.deleteDownloadedEpisode(); PodcastSubscriptionsManager.getInstance().removedPlayableEpisode(podcastEpisode); using (var db = new PodcastSqlModel()) { m_episodeModel = db.episodeForEpisodeId(m_episodeModel.EpisodeId); } this.DataContext = null; this.DataContext = m_episodeModel; }
private void processOngoingTransfer() { // If key exists, we know we have need to process a download request. if (m_applicationSettings.Contains(App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID)) { Debug.WriteLine("Found a episode download that we need to process."); int downloadingEpisodeId = (int)m_applicationSettings[App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID]; m_currentEpisodeDownload = null; using (var db = new PodcastSqlModel()) { m_currentEpisodeDownload = db.episodeForEpisodeId(downloadingEpisodeId); } if (m_currentEpisodeDownload == null) { Debug.WriteLine("Something went wrong. Got NULL episode when asking for episode id " + downloadingEpisodeId); m_applicationSettings.Remove(App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID); m_applicationSettings.Save(); return; } if (BackgroundTransferService.Requests.Count() > 0) { // Found an ongoing request. Debug.WriteLine("Found an ongoing transfer..."); m_currentBackgroundTransfer = BackgroundTransferService.Requests.ElementAt(0); m_currentBackgroundTransfer.TransferStatusChanged += new EventHandler <BackgroundTransferEventArgs>(backgroundTransferStatusChanged); m_currentEpisodeDownload.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloading; m_currentEpisodeDownload.DownloadRequest = m_currentBackgroundTransfer; m_episodeDownloadQueue.Enqueue(m_currentEpisodeDownload); ProcessTransfer(m_currentBackgroundTransfer); saveEpisodeInfoToDB(m_currentEpisodeDownload); } else { // No ongoing requests found. Then we need to process a finished request. // Probably happened in the background while we were suspended. Debug.WriteLine("Found a completed request."); updateEpisodeWhenDownloaded(m_currentEpisodeDownload); m_applicationSettings.Remove(App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID); m_applicationSettings.Save(); } } }
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(); } }
// Code to execute when the application is launching (eg, from Start) // This code will not execute when the application is reactivated private void Application_Launching(object sender, LaunchingEventArgs e) { // IsolatedStorageExplorer.Explorer.Start("192.168.0.6"); using (var db = new PodcastSqlModel()) { db.createDB(); } CheckLicense(); // Updates episodes from the audio agent. refreshEpisodesFromAudioAgent(); handleRemovingIconFiles(); }
private void workerSortPlaylist(object sender, DoWorkEventArgs args) { int selectedSortOrderIndex = (int)args.Argument; using (var playlistDB = new PlaylistDBContext()) { if (playlistDB.Playlist.Count() <= 1) { return; } PodcastSqlModel sqlContext = new PodcastSqlModel(); IEnumerable <PlaylistItem> newSortOrderQuery = null; List <PlaylistItem> newSortOrder = new List <PlaylistItem>(); var query = playlistDB.Playlist.AsEnumerable().Join(episodes(sqlContext), item => item.EpisodeId, episode => episode.EpisodeId, (item, episode) => new { PlaylistItem = item, PodcastEpisodeModel = episode }); switch (selectedSortOrderIndex) { // Oldest first case 0: newSortOrderQuery = query.OrderBy(newPlaylistItem => newPlaylistItem.PodcastEpisodeModel.EpisodePublished) .Select(newPlaylistItem => newPlaylistItem.PlaylistItem).AsEnumerable(); break; // Newest first. case 1: newSortOrderQuery = query.OrderByDescending(newPlaylistItem => newPlaylistItem.PodcastEpisodeModel.EpisodePublished) .Select(newPlaylistItem => newPlaylistItem.PlaylistItem).AsEnumerable(); break; } int i = 0; foreach (PlaylistItem item in newSortOrderQuery) { PlaylistItem newItem = item; newItem.OrderNumber = i++; newSortOrder.Add(newItem); } playlistDB.Playlist.DeleteAllOnSubmit(playlistDB.Playlist); playlistDB.Playlist.InsertAllOnSubmit(newSortOrder); playlistDB.SubmitChanges(); } }
public async void deleteSubscription(PodcastSubscriptionModel podcastSubscriptionModel) { OnPodcastChannelDeleteStarted(this, null); await Task.Run(() => { using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel dbSubscription = db.Subscriptions.First(s => s.PodcastId == podcastSubscriptionModel.PodcastId); dbSubscription.cleanupForDeletion(); db.deleteSubscription(dbSubscription); } }); OnPodcastChannelDeleteFinished(this, null); OnPodcastChannelRemoved(podcastSubscriptionModel); }
public void playPlaylistItem(int tappedPlaylistItemId) { int episodeId = -1; using (var db = new PlaylistDBContext()) { if (db.Playlist.Count() < 1) { return; } // Did we tap the item that is currently playing? PlaylistItem current = db.Playlist.FirstOrDefault(item => item.IsCurrent == true); if (current != null && current.ItemId == tappedPlaylistItemId) { Debug.WriteLine("Tapped on the currently playing episode. I am not changing the track..."); // Always open the player UI when playlist item is tapped. var handler = OnOpenPodcastPlayer; if (handler != null) { OnOpenPodcastPlayer(this, new EventArgs()); } return; } episodeId = (int)db.Playlist.Where(item => item.ItemId == tappedPlaylistItemId).Select(item => item.EpisodeId).First(); } PodcastEpisodeModel episode = null; using (var db = new PodcastSqlModel()) { episode = db.Episodes.First(ep => ep.EpisodeId == episodeId); } if (episode != null) { play(episode, true); } else { Debug.WriteLine("Warning: Could not play episode: " + episodeId); } }
public void addToPlayqueue(PodcastEpisodeModel episode, bool showNotification = true) { using (var db = new PlaylistDBContext()) { addToPlayqueue(episode, db); db.SubmitChanges(); } using (var db = new PodcastSqlModel()) { sortPlaylist(db.settings().PlaylistSortOrder); } if (showNotification) { showAddedNotification(1); } }
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); }
public void addToPlayqueue(Collection <PodcastEpisodeModel> episodes) { using (var db = new PlaylistDBContext()) { foreach (PodcastEpisodeModel e in episodes) { addToPlayqueue(e, db); } db.SubmitChanges(); } using (var db = new PodcastSqlModel()) { sortPlaylist(db.settings().PlaylistSortOrder); } App.mainViewModels.PlayQueue = new ObservableCollection <PlaylistItem>(); showAddedNotification(episodes.Count); }
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); } }
public void cleanListenedEpisodes(PodcastSubscriptionModel podcastSubscriptionModel) { using (var db = new PodcastSqlModel()) { float listenedEpisodeThreshold = 0.0F; listenedEpisodeThreshold = (float)db.settings().ListenedThreashold / (float)100.0; var queryDelEpisodes = db.Episodes.Where(episode => episode.PodcastId == podcastSubscriptionModel.PodcastId).AsEnumerable() .Where(ep => (ep.EpisodePlayState == PodcastEpisodeModel.EpisodePlayStateEnum.Listened || (ep.EpisodeFile != "" && ((ep.TotalLengthTicks > 0 && ep.SavedPlayPos > 0) && ((float)((float)ep.SavedPlayPos / (float)ep.TotalLengthTicks) > listenedEpisodeThreshold)))) ).AsEnumerable(); foreach (var episode in queryDelEpisodes) { episode.deleteDownloadedEpisode(); } } }
private void setupPlayerUIContent(PodcastEpisodeModel currentEpisode) { if (currentEpisode == null) { return; } Debug.WriteLine("Setting up player UI."); if (currentEpisode.EpisodeName == PodcastEpisodeName.Text) { return; } using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel s = db.Subscriptions.Where(sub => sub.PodcastId == currentEpisode.PodcastId).FirstOrDefault(); PodcastLogo.Source = s.PodcastLogo; PodcastEpisodeName.Text = currentEpisode.EpisodeName; } }
private void PlayHistoryItemTapped(object sender, System.Windows.Input.GestureEventArgs e) { PodcastEpisodeModel episode = DataContext as PodcastEpisodeModel; if (episode == null) { App.showNotificationToast("You don't subscribe to the podcast anymore."); return; } using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel sub = db.Subscriptions.FirstOrDefault(s => s.PodcastId == episode.PodcastId); if (sub == null) { App.showNotificationToast("You don't subscribe to the podcast anymore."); return; } } (Application.Current.RootVisual as PhoneApplicationFrame).Navigate(new Uri(string.Format("/Views/PodcastEpisodes.xaml?podcastId={0}", episode.PodcastId), UriKind.Relative)); }
private void updatePrimary(PodcastEpisodeModel currentEpisode) { ShellTile PrimaryTile = ShellTile.ActiveTiles.First(); if (PrimaryTile != null) { StandardTileData tile = new StandardTileData(); String tileImageLocation = ""; String podcastLogoLocalLocation = ""; // Copy the logo file to tile's shared location. using (IsolatedStorageFile myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication()) { using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel sub = db.Subscriptions.First(s => s.PodcastId == currentEpisode.PodcastId); podcastLogoLocalLocation = sub.PodcastLogoLocalLocation; tile.BackTitle = sub.PodcastName; } if (myIsolatedStorage.FileExists(podcastLogoLocalLocation) == false) { // Cover art does not exist, we cannot do anything. Give up, don't put it to Live tile. Debug.WriteLine("Podcasts cover art not found."); return; } tileImageLocation = "Shared/ShellContent/" + podcastLogoLocalLocation.Split('/')[1]; if (myIsolatedStorage.FileExists(tileImageLocation) == false) { myIsolatedStorage.CopyFile(podcastLogoLocalLocation, tileImageLocation); } } tile.BackBackgroundImage = new Uri("isostore:/" + tileImageLocation, UriKind.Absolute); PrimaryTile.Update(tile); } }
private void startNextEpisodeDownload(TransferPreferences useTransferPreferences = TransferPreferences.AllowCellularAndBattery) { if (BackgroundTransferService.Requests.Count() > 0) { // For some reason there are still old requests in the background transfer service. // Let's clean everything and start over. foreach (BackgroundTransferRequest t in BackgroundTransferService.Requests.AsEnumerable()) { BackgroundTransferService.Remove(t); } } if (m_episodeDownloadQueue.Count > 0) { m_currentEpisodeDownload = m_episodeDownloadQueue.Peek(); Uri downloadUri; try { downloadUri = new Uri(m_currentEpisodeDownload.EpisodeDownloadUri, UriKind.Absolute); } catch (Exception e) { App.showErrorToast("Cannot download the episode."); Debug.WriteLine("Cannot download the episode. URI exception: " + e.Message); m_currentEpisodeDownload.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Idle; m_episodeDownloadQueue.Dequeue(); saveEpisodeInfoToDB(m_currentEpisodeDownload); startNextEpisodeDownload(); return; } m_currentEpisodeDownload.EpisodeFile = generateLocalEpisodeFileName(m_currentEpisodeDownload); if (string.IsNullOrEmpty(m_currentEpisodeDownload.EpisodeFile)) { App.showErrorToast("Cannot download the episode."); Debug.WriteLine("Cannot download the episode. Episode file name is null or empty."); m_currentEpisodeDownload.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Idle; m_episodeDownloadQueue.Dequeue(); saveEpisodeInfoToDB(m_currentEpisodeDownload); startNextEpisodeDownload(); return; } // Create a new background transfer request for the podcast episode download. m_currentBackgroundTransfer = new BackgroundTransferRequest(downloadUri, new Uri(m_currentEpisodeDownload.EpisodeFile, UriKind.Relative)); if (useTransferPreferences == TransferPreferences.None) { m_currentBackgroundTransfer.TransferPreferences = TransferPreferences.None; } else if (canAllowCellularDownload(m_currentEpisodeDownload)) { bool settingsAllowCellular = false; using (var db = new PodcastSqlModel()) { settingsAllowCellular = db.settings().IsUseCellularData; } Debug.WriteLine("Settings: Allow cellular download: " + settingsAllowCellular); if (settingsAllowCellular && canDownloadOverCellular()) { m_currentBackgroundTransfer.TransferPreferences = TransferPreferences.AllowCellularAndBattery; } else { m_currentBackgroundTransfer.TransferPreferences = TransferPreferences.AllowBattery; } } else { m_currentBackgroundTransfer.TransferPreferences = TransferPreferences.None; } Debug.WriteLine("m_currentBackgroundTransfer.TransferPreferences = " + m_currentBackgroundTransfer.TransferPreferences.ToString()); m_currentBackgroundTransfer.TransferStatusChanged += new EventHandler<BackgroundTransferEventArgs>(backgroundTransferStatusChanged); // Store request to the episode. m_currentEpisodeDownload.DownloadRequest = m_currentBackgroundTransfer; m_applicationSettings.Remove(App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID); m_applicationSettings.Add(App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID, m_currentEpisodeDownload.EpisodeId); m_applicationSettings.Save(); try { BackgroundTransferService.Add(m_currentBackgroundTransfer); } catch (InvalidOperationException) { foreach (BackgroundTransferRequest r in BackgroundTransferService.Requests) { BackgroundTransferService.Remove(r); } BackgroundTransferService.Add(m_currentBackgroundTransfer); } } }
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(); } }
public void removeFromPlayqueue(int itemId) { using (var db = new PlaylistDBContext()) { PlaylistItem itemToRemove = db.Playlist.FirstOrDefault(item => item.ItemId == itemId); if (itemToRemove != null) { PodcastEpisodeModel episode = null; using (var episodeDb = new PodcastSqlModel()) { episode = episodeDb.episodeForPlaylistItem(itemToRemove); if (episode != null) { if (episode.isListened()) { episode.markAsListened(episodeDb.settings().IsAutoDelete); } } else { Debug.WriteLine("Warning: Could not get episode for item id: " + itemToRemove.ItemId); } } db.Playlist.DeleteOnSubmit(itemToRemove); db.SubmitChanges(); App.mainViewModels.PlayQueue = new ObservableCollection<PlaylistItem>(); } } }
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 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); }
public void sortPlaylist(int sortOrder) { using (var playlistDB = new PlaylistDBContext()) { if (playlistDB.Playlist.Count() <= 1) { return; } PodcastSqlModel sqlContext = new PodcastSqlModel(); IEnumerable<PlaylistItem> newSortOrderQuery = null; List<PlaylistItem> newSortOrder = new List<PlaylistItem>(); var query = playlistDB.Playlist.AsEnumerable().Join(episodes(sqlContext), item => item.EpisodeId, episode => episode.EpisodeId, (item, episode) => new { PlaylistItem = item, PodcastEpisodeModel = episode }); switch (sortOrder) { // Oldest first case 0: newSortOrderQuery = query.OrderBy(newPlaylistItem => newPlaylistItem.PodcastEpisodeModel.EpisodePublished) .Select(newPlaylistItem => newPlaylistItem.PlaylistItem).AsEnumerable(); break; // Newest first. case 1: newSortOrderQuery = query.OrderByDescending(newPlaylistItem => newPlaylistItem.PodcastEpisodeModel.EpisodePublished) .Select(newPlaylistItem => newPlaylistItem.PlaylistItem).AsEnumerable(); break; } int i = 0; foreach (PlaylistItem item in newSortOrderQuery) { PlaylistItem newItem = item; newItem.OrderNumber = i++; newSortOrder.Add(newItem); } playlistDB.Playlist.DeleteAllOnSubmit(playlistDB.Playlist); playlistDB.Playlist.InsertAllOnSubmit(newSortOrder); playlistDB.SubmitChanges(); } Deployment.Current.Dispatcher.BeginInvoke(() => { App.mainViewModels.PlayQueue = new ObservableCollection<PlaylistItem>(); }); }
public void addToPlayqueue(Collection<PodcastEpisodeModel> episodes) { using (var db = new PlaylistDBContext()) { foreach (PodcastEpisodeModel e in episodes) { addToPlayqueue(e, db); } db.SubmitChanges(); } using (var db = new PodcastSqlModel()) { sortPlaylist(db.settings().PlaylistSortOrder); } App.mainViewModels.PlayQueue = new ObservableCollection<PlaylistItem>(); showAddedNotification(episodes.Count); }
/************************************* Public implementations *******************************/ public static PodcastSqlModel getInstance() { if (m_instance == null) { m_instance = new PodcastSqlModel(); } return m_instance; }
private static IEnumerable<PodcastEpisodeModel> episodes(PodcastSqlModel sqlContext) { return sqlContext.Episodes.AsQueryable(); }
private void workerSortPlaylist(object sender, DoWorkEventArgs args) { int selectedSortOrderIndex = (int)args.Argument; using (var playlistDB = new PlaylistDBContext()) { if (playlistDB.Playlist.Count() <= 1) { return; } PodcastSqlModel sqlContext = new PodcastSqlModel(); IEnumerable<PlaylistItem> newSortOrderQuery = null; List<PlaylistItem> newSortOrder = new List<PlaylistItem>(); var query = playlistDB.Playlist.AsEnumerable().Join(episodes(sqlContext), item => item.EpisodeId, episode => episode.EpisodeId, (item, episode) => new { PlaylistItem = item, PodcastEpisodeModel = episode }); switch (selectedSortOrderIndex) { // Oldest first case 0: newSortOrderQuery = query.OrderBy(newPlaylistItem => newPlaylistItem.PodcastEpisodeModel.EpisodePublished) .Select(newPlaylistItem => newPlaylistItem.PlaylistItem).AsEnumerable(); break; // Newest first. case 1: newSortOrderQuery = query.OrderByDescending(newPlaylistItem => newPlaylistItem.PodcastEpisodeModel.EpisodePublished) .Select(newPlaylistItem => newPlaylistItem.PlaylistItem).AsEnumerable(); break; } int i = 0; foreach (PlaylistItem item in newSortOrderQuery) { PlaylistItem newItem = item; newItem.OrderNumber = i++; newSortOrder.Add(newItem); } playlistDB.Playlist.DeleteAllOnSubmit(playlistDB.Playlist); playlistDB.Playlist.InsertAllOnSubmit(newSortOrder); playlistDB.SubmitChanges(); } }
public PodcastEpisodeModel updateCurrentlyPlayingEpisode() { PlaylistItem plItem = null; using (var playlistDb = new PlaylistDBContext()) { if (playlistDb.Playlist.Count() == 0) { return null; } plItem = playlistDb.Playlist.Where(item => item.IsCurrent).FirstOrDefault(); } if (plItem != null) { using (var db = new PodcastSqlModel()) { PodcastEpisodeModel currentEpisode = db.Episodes.Where(ep => ep.EpisodeId == plItem.EpisodeId).FirstOrDefault(); CurrentlyPlayingEpisode = currentEpisode; return currentEpisode; } } return null; }
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); } }
private void completePodcastDownload(BackgroundTransferRequest transferRequest) { // If the status code of a completed transfer is 200 or 206, the // transfer was successful if (transferRequest.TransferError == null && (transferRequest.StatusCode == 200 || transferRequest.StatusCode == 206)) { Debug.WriteLine("Transfer request completed succesfully."); updateEpisodeWhenDownloaded(m_currentEpisodeDownload); // Add downloaded episode to play queue, if set. using (var db = new PodcastSqlModel()) { if (db.settings().IsAddDownloadsToPlayQueue) { PodcastPlaybackManager.getInstance().addSilentlyToPlayqueue(m_currentEpisodeDownload); } } } else { Debug.WriteLine("Transfer request completed with error code: " + transferRequest.StatusCode + ", " + transferRequest.TransferError); switch (transferRequest.StatusCode) { case 0: Debug.WriteLine("Request canceled."); break; // If error code is 200 but we still got an error, this means the max. transfer size exceeded. // This is because the podcast feed announced a different download size than what the file actually is. // If user wants, we can try again with larger file download size policy. case 200: Debug.WriteLine("Maxiumum download size exceeded. Shall we try again?"); if (MessageBox.Show("Podcast feed announced wrong file size. Do you want to download again with larger file download settings?", "Podcast download failed", MessageBoxButton.OKCancel) == MessageBoxResult.OK) { if (MessageBox.Show("Please connect your phone to an external power source and to a WiFi network.", "Attention", MessageBoxButton.OK) == MessageBoxResult.OK) { Debug.WriteLine("Download the same episode again, with preferences None."); // We download the same file again, but this time we force the TransferPrefernces to be None. startNextEpisodeDownload(TransferPreferences.None); return; } } break; case 301: App.showErrorToast("WP8 cannot download from this location."); break; default: App.showErrorToast("Could not download the episode\nfrom the server."); break; } if (m_currentEpisodeDownload != null) { m_currentEpisodeDownload.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Idle; m_currentEpisodeDownload.deleteDownloadedEpisode(); } } saveEpisodeInfoToDB(m_currentEpisodeDownload); cleanupEpisodeDownload(transferRequest); // And start a next round of downloading. startNextEpisodeDownload(); }
private void processOngoingTransfer() { // If key exists, we know we have need to process a download request. if (m_applicationSettings.Contains(App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID)) { Debug.WriteLine("Found a episode download that we need to process."); int downloadingEpisodeId = (int)m_applicationSettings[App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID]; m_currentEpisodeDownload = null; using (var db = new PodcastSqlModel()) { m_currentEpisodeDownload = db.episodeForEpisodeId(downloadingEpisodeId); } if (m_currentEpisodeDownload == null) { Debug.WriteLine("Something went wrong. Got NULL episode when asking for episode id " + downloadingEpisodeId); m_applicationSettings.Remove(App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID); m_applicationSettings.Save(); return; } if (BackgroundTransferService.Requests.Count() > 0) { // Found an ongoing request. Debug.WriteLine("Found an ongoing transfer..."); m_currentBackgroundTransfer = BackgroundTransferService.Requests.ElementAt(0); m_currentBackgroundTransfer.TransferStatusChanged += new EventHandler<BackgroundTransferEventArgs>(backgroundTransferStatusChanged); m_currentEpisodeDownload.EpisodeDownloadState = PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloading; m_currentEpisodeDownload.DownloadRequest = m_currentBackgroundTransfer; m_episodeDownloadQueue.Enqueue(m_currentEpisodeDownload); ProcessTransfer(m_currentBackgroundTransfer); saveEpisodeInfoToDB(m_currentEpisodeDownload); } else { // No ongoing requests found. Then we need to process a finished request. // Probably happened in the background while we were suspended. Debug.WriteLine("Found a completed request."); updateEpisodeWhenDownloaded(m_currentEpisodeDownload); m_applicationSettings.Remove(App.LSKEY_PODCAST_EPISODE_DOWNLOADING_ID); m_applicationSettings.Save(); } } }
private AudioTrack getAudioTrackForEpisode(PodcastEpisodeModel currentEpisode) { if (currentEpisode == null || String.IsNullOrEmpty(currentEpisode.EpisodeFile)) { return null; } Uri episodeLocation; try { episodeLocation = new Uri(currentEpisode.EpisodeFile, UriKind.Relative); } catch(Exception) { return null; } using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel sub = db.Subscriptions.First(s => s.PodcastId == currentEpisode.PodcastId); return new AudioTrack(episodeLocation, currentEpisode.EpisodeName, sub.PodcastName, "", new Uri(sub.PodcastLogoLocalLocation, UriKind.Relative)); } }
private AudioTrack getAudioStreamForEpisode(PodcastEpisodeModel episode) { if (episode == null || String.IsNullOrEmpty(episode.EpisodeDownloadUri)) { return null; } Uri episodeLocation; try { episodeLocation = new Uri(episode.EpisodeDownloadUri, UriKind.Absolute); } catch (Exception) { return null; } using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel sub = db.Subscriptions.First(s => s.PodcastId == episode.PodcastId); return new AudioTrack(episodeLocation, episode.EpisodeName, sub.PodcastName, "", new Uri(sub.PodcastLogoLocalLocation, UriKind.Relative)); } }