protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e) { int podcastId = int.Parse(NavigationContext.QueryString["podcastId"]); m_subscription = m_podcastSqlModel.subscriptionModelForIndex(podcastId); m_episodes = new ObservableCollection<PodcastEpisodeModel>(m_podcastSqlModel.episodesForSubscription(m_subscription)); this.PodcastName.Text = m_subscription.PodcastName; this.PodcastDescription.Text = m_subscription.PodcastDescription; this.PodcastIcon.Source = m_subscription.PodcastLogo; this.EpisodeList.ItemsSource = m_episodes; }
public void reloadPartiallyPlayedEpisodes() { PartiallyPlayedEpisodes = partiallyPlayedEpisodesCount(PodcastId); using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel sub = db.Subscriptions.FirstOrDefault(s => s.PodcastId == PodcastId); if (sub != null) { sub.PartiallyPlayedEpisodes = m_partiallyPlayedEpisodes; db.SubmitChanges(); } } }
void wc_RefetchedRSSForLogoCompleted(object sender, DownloadStringCompletedEventArgs e) { if (e.Error != null) { Debug.WriteLine("Malformed podcast address."); return; } PodcastSubscriptionModel subscription = PodcastFactory.podcastModelFromRSS((string)e.Result); PodcastLogoUrl = subscription.PodcastLogoUrl; fetchChannelLogo(); }
public PodcastSubscriptionModel getSubscriptionModel() { PodcastSubscriptionModel sub = null; using (var db = new PodcastSqlModel()) { sub = db.Subscriptions.FirstOrDefault(s => s.PodcastId == this.PodcastId); if (sub == null) { Debug.WriteLine("Warning: Got null subscription!"); } } return(sub); }
protected override void OnBackKeyPress(System.ComponentModel.CancelEventArgs e) { PodcastSubscriptionModel subscriptionDataContext = this.DataContext as PodcastSubscriptionModel; PodcastSubscriptionModel subscription = null; using (var db = new PodcastSqlModel()) { subscription = db.subscriptionModelForIndex(m_subscription.PodcastId); subscription.SubscriptionSelectedKeepNumEpisodesIndex = subscriptionDataContext.SubscriptionSelectedKeepNumEpisodesIndex; subscription.IsSubscribed = subscriptionDataContext.IsSubscribed; subscription.IsAutoDownload = subscriptionDataContext.IsAutoDownload; subscription.SubscriptionIsDeleteEpisodes = subscriptionDataContext.SubscriptionIsDeleteEpisodes; db.SubmitChanges(); } m_subscription = null; NavigationService.GoBack(); }
public List<PodcastEpisodeModel> episodesForSubscription(PodcastSubscriptionModel subscriptionModel) { lock (this) { var query = from PodcastEpisodeModel episode in subscriptionModel.Episodes orderby episode.EpisodePublished descending select episode; return new List<PodcastEpisodeModel>(query); } }
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e) { m_podcastId = int.Parse(NavigationContext.QueryString["podcastId"]); using (var db = new PodcastSqlModel()) { m_subscription = db.subscriptionModelForIndex(m_podcastId); m_cleanListenedEpisodesAutomatically = db.settings().IsAutoDelete; if (m_cleanListenedEpisodesAutomatically) { PodcastSubscriptionsManager.getInstance().cleanListenedEpisodes(m_subscription); } } m_playableEpisodes = m_subscription.PlayableEpisodes; this.DataContext = m_subscription; PodcastSubscriptionsManager.getInstance().NewPlayableEpisode -= new PodcastSubscriptionsManager.EpisodesEventHandler(m_subscription_NewPlayableEpisode); PodcastSubscriptionsManager.getInstance().RemovedPlayableEpisode -= new PodcastSubscriptionsManager.EpisodesEventHandler(m_subscription_RemovedPlayableEpisode); PodcastSubscriptionsManager.getInstance().NewPlayableEpisode += new PodcastSubscriptionsManager.EpisodesEventHandler(m_subscription_NewPlayableEpisode); PodcastSubscriptionsManager.getInstance().RemovedPlayableEpisode += new PodcastSubscriptionsManager.EpisodesEventHandler(m_subscription_RemovedPlayableEpisode); bool forceUpdate = false; try { forceUpdate = String.IsNullOrEmpty(NavigationContext.QueryString["forceUpdate"]) == false && bool.Parse(NavigationContext.QueryString["forceUpdate"]); } catch (KeyNotFoundException) { forceUpdate = false; } if (forceUpdate) { // Clear the back stack while (((App)Application.Current).RootFrame.RemoveBackEntry() != null) ; ShellTile pinnedSubscriptionTile = m_subscription.getSubscriptionsLiveTile(); if (pinnedSubscriptionTile != null) { StandardTileData tileData = new StandardTileData(); tileData.Count = 0; tileData.BackTitle = ""; pinnedSubscriptionTile.Update(tileData); } PodcastSubscriptionsManager.getInstance().refreshSubscription(m_subscription); } m_subscription.PodcastCleanStarted -= new PodcastSubscriptionModel.SubscriptionModelHandler(m_subscription_PodcastCleanStarted); m_subscription.PodcastCleanFinished -= new PodcastSubscriptionModel.SubscriptionModelHandler(m_subscription_PodcastCleanFinished); m_subscription.PodcastCleanStarted += new PodcastSubscriptionModel.SubscriptionModelHandler(m_subscription_PodcastCleanStarted); m_subscription.PodcastCleanFinished += new PodcastSubscriptionModel.SubscriptionModelHandler(m_subscription_PodcastCleanFinished); // Clean old episodes from the listing. if (SettingsModel.keepNumEpisodesForSelectedIndex(m_subscription.SubscriptionSelectedKeepNumEpisodesIndex) != SettingsModel.KEEP_ALL_EPISODES) { m_subscription.cleanOldEpisodes(SettingsModel.keepNumEpisodesForSelectedIndex(m_subscription.SubscriptionSelectedKeepNumEpisodesIndex)); } if (App.episodeDownloadManager == null) { App.episodeDownloadManager = PodcastEpisodesDownloadManager.getInstance(); } App.episodeDownloadManager.OnPodcastEpisodeDownloadStateChanged += new PodcastDownloadManagerHandler(episodeDownloadManager_PodcastEpisodeDownloadStateChanged); PodcastPlaybackManager.getInstance().OnPodcastStartedPlaying += new EventHandler(PodcastEpisodes_OnPodcastPlaystateChanged); PodcastPlaybackManager.getInstance().OnPodcastStoppedPlaying += new EventHandler(PodcastEpisodes_OnPodcastPlaystateChanged); }
private void subscriptionManager_OnPodcastChannelAdded(PodcastSubscriptionModel s) { Debug.WriteLine("Subscription added"); List<PodcastSubscriptionModel> subs = m_subscriptions.ToList(); subs.Add(s); subs.Sort(PodcastSubscriptionSortComparator); m_subscriptions = new ObservableCollection<PodcastSubscriptionModel>(subs); this.SubscriptionsList.ItemsSource = m_subscriptions; NoSubscriptionsLabel.Visibility = Visibility.Collapsed; // Update all episodes to the latest list. App.mainViewModels.LatestEpisodesListProperty = new ObservableCollection<PodcastEpisodeModel>(); }
public List<PodcastEpisodeModel> episodesForSubscription(PodcastSubscriptionModel subscriptionModel) { var query = from PodcastEpisodeModel episode in Episodes where episode.PodcastId == subscriptionModel.PodcastId orderby episode.EpisodePublished descending select episode; List<PodcastEpisodeModel> episodes = new List<PodcastEpisodeModel>(query); return episodes; }
public IEnumerable<PodcastEpisodeModel> playableEpisodesForSubscription(PodcastSubscriptionModel subscription) { var query = from PodcastEpisodeModel episode in Episodes where (episode.PodcastId == subscription.PodcastId && episode.EpisodeFile != "" && (episode.EpisodePlayState == PodcastEpisodeModel.EpisodePlayStateEnum.Downloaded || episode.EpisodePlayState == PodcastEpisodeModel.EpisodePlayStateEnum.Playing || episode.EpisodePlayState == PodcastEpisodeModel.EpisodePlayStateEnum.Listened || episode.EpisodePlayState == PodcastEpisodeModel.EpisodePlayStateEnum.Paused || episode.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.Downloading || episode.EpisodeDownloadState == PodcastEpisodeModel.EpisodeDownloadStateEnum.Queued)) orderby episode.EpisodePublished descending select episode; return query; }
public PodcastEpisodesManager(PodcastSubscriptionModel subscriptionModel) { m_subscriptionModel = subscriptionModel; }
public void addSubscription(PodcastSubscriptionModel podcastModel) { Subscriptions.InsertOnSubmit(podcastModel); SubmitChanges(); }
public void refreshSubscription(PodcastSubscriptionModel subscription) { m_subscriptions = new List<PodcastSubscriptionModel>(); m_subscriptions.Add(subscription); refreshNextSubscription(); }
public void podcastPlaystateChanged(PodcastSubscriptionModel s) { if (OnPodcastChannelPlayedCountChanged != null) { OnPodcastChannelPlayedCountChanged(s); } }
private BitmapImage getLogoForSubscription(PodcastSubscriptionModel subscription) { bool fillCache = false; BitmapImage logo = null; if (m_logoCache.ContainsKey(subscription.PodcastId) == false) { fillCache = true; } else { logo = m_logoCache[subscription.PodcastId].Target as BitmapImage; if (logo == null) { fillCache = true; } } if (fillCache) { logo = subscription.PodcastLogo; WeakReference cachedLogo = new WeakReference(logo); m_logoCache[subscription.PodcastId] = cachedLogo; } return logo; }
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 deleteSubscription(PodcastSubscriptionModel podcastSubscriptionModel) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += new DoWorkEventHandler(deleteSubscriptionFromDB); worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(deleteSubscriptionFromDBCompleted); worker.RunWorkerAsync(podcastSubscriptionModel); OnPodcastChannelDeleteStarted(this, null); }
private void subscriptionManager_OnPodcastChannelRemoved(PodcastSubscriptionModel s) { Debug.WriteLine("Subscription deleted."); List<PodcastSubscriptionModel> subs = m_subscriptions.ToList(); for (int i = 0; i < subs.Count; i++) { if (subs[i].PodcastId == s.PodcastId) { subs.RemoveAt(i); break; } } // Update all episodes to the latest list. App.mainViewModels.LatestEpisodesListProperty = new ObservableCollection<PodcastEpisodeModel>(); m_subscriptions = new ObservableCollection<PodcastSubscriptionModel>(subs); this.SubscriptionsList.ItemsSource = m_subscriptions; if (m_subscriptions.Count > 0) { NoSubscriptionsLabel.Visibility = Visibility.Collapsed; } else { NoSubscriptionsLabel.Visibility = Visibility.Visible; } }
private void subscriptionManager_OnPodcastChannelPlayedCountChanged(PodcastSubscriptionModel s) { Debug.WriteLine("Play status changed."); List<PodcastSubscriptionModel> subs = m_subscriptions.ToList(); foreach (PodcastSubscriptionModel sub in subs) { if (sub.PodcastId == s.PodcastId) { Deployment.Current.Dispatcher.BeginInvoke(() => { sub.reloadUnplayedPlayedEpisodes(); sub.reloadPartiallyPlayedEpisodes(); }); break; } } }
void PodcastSubscriptionControl_Loaded(object sender, RoutedEventArgs e) { m_subscription = DataContext as PodcastSubscriptionModel; m_subscription.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(m_subscription_PropertyChanged); updateUnplayedEpisodesText(); }
public void podcastSubscriptionRemoved(PodcastSubscriptionModel s) { if (OnPodcastChannelRemoved != null) { OnPodcastChannelRemoved(s); } }
public static PodcastSubscriptionModel podcastModelFromRSS(string podcastRss) { XDocument rssXmlDoc; try { rssXmlDoc = XDocument.Parse(podcastRss); } catch (System.Exception e) { Debug.WriteLine("ERROR: Cannot parse podcast RSS feed. Status: " + e.ToString()); return null; } bool validFeed = true; XNamespace itunes = "http://www.itunes.com/dtds/podcast-1.0.dtd"; var query = (from channel in rssXmlDoc.Descendants("channel") select new { Title = (string)channel.Element("title"), Description = (string)channel.Element("description"), ImageUrl = (channel.Element(itunes + "image") != null ? channel.Element(itunes + "image").Attribute("href").Value : @""), Link = (string)channel.Element("link") }).FirstOrDefault(); if (query == null) { validFeed = false; } if (String.IsNullOrEmpty(query.Link)) { validFeed = false; } if (validFeed == false) { Debug.WriteLine("ERROR: Cannot get all necessary fields from the podcast RSS."); return null; } PodcastSubscriptionModel podcastModel = new PodcastSubscriptionModel(); podcastModel.PodcastName = query.Title; podcastModel.PodcastDescription = query.Description; podcastModel.PodcastLogoUrl = new Uri(query.ImageUrl, UriKind.RelativeOrAbsolute); podcastModel.PodcastShowLink = query.Link; Debug.WriteLine("Got podcast subscription:" + "\n\t* Name:\t\t\t\t\t" + podcastModel.PodcastName + "\n\t* Description:\t\t\t" + podcastModel.PodcastDescription + "\n\t* LogoUrl:\t\t\t\t" + podcastModel.PodcastLogoUrl ); return podcastModel; }
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(); } } }
public void updatePodcastEpisodes() { Debug.WriteLine("Updating episodes for podcast: " + m_subscriptionModel.PodcastName); bool subscriptionAddedNow = true; List <PodcastEpisodeModel> episodes = null; using (var db = new PodcastSqlModel()) { episodes = db.episodesForSubscription(m_subscriptionModel); } DateTime latestEpisodePublishDate = new DateTime(); if (episodes.Count > 0) { // The episodes are in descending order as per publish date. // So take the first episode and we have the latest known publish date. latestEpisodePublishDate = episodes[0].EpisodePublished; // If we already have episodes, this subscription is not being added now. subscriptionAddedNow = false; } episodes = null; Debug.WriteLine("\nStarting to parse episodes for podcast: " + m_subscriptionModel.PodcastName); List <PodcastEpisodeModel> newPodcastEpisodes = PodcastFactory.newPodcastEpisodes(m_subscriptionModel.CachedPodcastRSSFeed, latestEpisodePublishDate); m_subscriptionModel.CachedPodcastRSSFeed = ""; if (newPodcastEpisodes == null) { Debug.WriteLine("WARNING: Got null list of new episodes."); return; } using (var db = new PodcastSqlModel()) { PodcastSubscriptionModel sub = db.Subscriptions.FirstOrDefault(s => s.PodcastId == m_subscriptionModel.PodcastId); if (sub == null) { Debug.WriteLine("Subscription NULL. Probably already deleted."); return; } PodcastEpisodeModel[] newEpisodesSet = new PodcastEpisodeModel[newPodcastEpisodes.Count]; newPodcastEpisodes.CopyTo(newEpisodesSet); // Let's check for duplicate episode names. This can happen if the subscription updates the "pubDate" // of the most recent episode in the feed, in which case the most recent one (at least) can become a duplicate entry. foreach (PodcastEpisodeModel newEpisode in newEpisodesSet.AsEnumerable()) { if (sub.Episodes.OrderByDescending(ep => ep.EpisodePublished).Take(10).ToArray().FirstOrDefault(ep => ep.EpisodeName == newEpisode.EpisodeName) != null) { Debug.WriteLine("Episode already found in the subscription, removing: " + newEpisode.EpisodeName); newPodcastEpisodes.Remove(newEpisode); } } db.insertEpisodesForSubscription(m_subscriptionModel, newPodcastEpisodes); // Indicate new episodes to the UI only when we are not adding the feed. // I.e. we want to show new episodes only when we refresh the feed at restart. if (subscriptionAddedNow == false) { int numOfNewPodcasts = newPodcastEpisodes.Count; Debug.WriteLine("Got {0} new episodes.", numOfNewPodcasts); Deployment.Current.Dispatcher.BeginInvoke(() => { m_subscriptionModel.addNumOfNewEpisodes(numOfNewPodcasts); }); sub.addNumOfNewEpisodes(numOfNewPodcasts); db.SubmitChanges(); } } if (m_subscriptionModel.IsAutoDownload && newPodcastEpisodes.Count > 0) { Deployment.Current.Dispatcher.BeginInvoke(() => { PodcastEpisodesDownloadManager.getInstance().addEpisodesToDownloadQueue(newPodcastEpisodes); }); } if (newPodcastEpisodes.Count > 0) { // Update subscription's information if it's pinned to home screen. updatePinnedInformation(); Deployment.Current.Dispatcher.BeginInvoke(() => { // This will call the setter for episode model in the UI that will notify the UI that the content has changed. m_subscriptionModel.EpisodesPublishedDescending = new ObservableCollection <PodcastEpisodeModel>(); }); } }
private string localLogoFileName(PodcastSubscriptionModel podcastModel) { string podcastLogoFilename; if (String.IsNullOrEmpty(podcastModel.PodcastLogoUrl.ToString())) { // Podcast logo URL is empty - use default placeholder logo. podcastLogoFilename = @"Podcatcher_generic_podcast_cover.png"; } else { // Parse the filename of the logo from the remote URL. string localPath = podcastModel.PodcastLogoUrl.LocalPath; podcastLogoFilename = localPath.Substring(localPath.LastIndexOf('/') + 1); } // Make podcast logo name random. // This is because, if for some reason, two podcasts have the same logo name and we delete // one of them, we don't want the other one to be affected. Just to be sure. StringBuilder podcastLogoFilename_sb = new StringBuilder(podcastLogoFilename); podcastLogoFilename_sb.Insert(0, m_random.Next().ToString()); string localPodcastLogoFilename = App.PODCAST_ICON_DIR + @"/" + podcastLogoFilename_sb.ToString(); Debug.WriteLine("Found icon filename: " + localPodcastLogoFilename); return localPodcastLogoFilename; }
public void deleteSubscription(PodcastSubscriptionModel podcastModel) { var queryDelEpisodes = from episode in Episodes where episode.PodcastId.Equals(podcastModel.PodcastId) select episode; foreach (var episode in queryDelEpisodes) { using (var episodeStore = IsolatedStorageFile.GetUserStoreForApplication()) { try { Debug.WriteLine("Deleting downloaded episode: " + episode.EpisodeFile); if (String.IsNullOrEmpty(episode.EpisodeFile) == false && episodeStore.FileExists(episode.EpisodeFile)) { episodeStore.DeleteFile(episode.EpisodeFile); } } catch (IsolatedStorageException) { } } Episodes.DeleteOnSubmit(episode); } var queryDelSubscription = (from subscription in Subscriptions where subscription.PodcastId.Equals(podcastModel.PodcastId) select subscription).First(); Subscriptions.DeleteOnSubmit(queryDelSubscription); SubmitChanges(); }
void m_subscription_PodcastCleanFinished() { cleanProgressOverlay.Visibility = Visibility.Collapsed; using (var db = new PodcastSqlModel()) { m_subscription = db.subscriptionModelForIndex(m_podcastId); } this.DataContext = m_subscription; this.EpisodeList.ItemsSource = m_subscription.EpisodesPublishedDescending; }
public void insertEpisodesForSubscription(PodcastSubscriptionModel subscriptionModel, List<PodcastEpisodeModel> newPodcastEpisodes) { if (newPodcastEpisodes.Count < 1) { return; } Debug.WriteLine("Writing {0} new episodes to SQL.", newPodcastEpisodes.Count); foreach (PodcastEpisodeModel episode in newPodcastEpisodes) { episode.PodcastId = subscriptionModel.PodcastId; Episodes.InsertOnSubmit(episode); subscriptionModel.Episodes.Add(episode); } SubmitChanges(); }
public PodcastEpisodesManager(PodcastSubscriptionModel subscriptionModel) { m_subscriptionModel = subscriptionModel; m_podcastsSqlModel = PodcastSqlModel.getInstance(); }
public List<PodcastEpisodeModel> unplayedEpisodesForSubscription(PodcastSubscriptionModel subscription) { var query = from episode in Episodes where (episode.PodcastId == subscription.PodcastId && episode.EpisodePlayState == PodcastEpisodeModel.EpisodePlayStateEnum.Downloaded && episode.EpisodePlayState != PodcastEpisodeModel.EpisodePlayStateEnum.Listened && episode.SavedPlayPos == 0) select episode; return new List<PodcastEpisodeModel>(query); }
public void deleteSubscription(PodcastSubscriptionModel podcastModel) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += new DoWorkEventHandler(deleteEpisodesFromDB); worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(deleteEpisodesFromDBCompleted); worker.RunWorkerAsync(podcastModel); }
public void deleteSubscription(PodcastSubscriptionModel podcastSubscriptionModel) { podcastSubscriptionModel.cleanupForDeletion(); m_podcastsSqlModel.deleteSubscription(podcastSubscriptionModel); }
private int PodcastSubscriptionSortComparator(PodcastSubscriptionModel s1, PodcastSubscriptionModel s2) { return s1.PodcastName.CompareTo(s2.PodcastName); }
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e) { if (m_subscription == null) { int podcastId = int.Parse(NavigationContext.QueryString["podcastId"]); using (var db = new PodcastSqlModel()) { m_subscription = db.subscriptionModelForIndex(podcastId); } } this.DataContext = m_subscription; }
private void MarkAllListened_Click(object sender, EventArgs e) { if (MessageBox.Show("Are you sure you want to mark all episodes as listened?", "Are you sure?", MessageBoxButton.OKCancel) == MessageBoxResult.OK) { List<PodcastEpisodeModel> episodes = null; using (var db = new PodcastSqlModel()) { episodes = db.episodesForSubscription(m_subscription); foreach (PodcastEpisodeModel episode in episodes) { episode.markAsListened(m_cleanListenedEpisodesAutomatically); } db.SubmitChanges(); PodcastSubscriptionsManager.getInstance().podcastPlaystateChanged(m_subscription); m_subscription = db.subscriptionModelForIndex(m_podcastId); } this.DataContext = m_subscription; this.EpisodeList.ItemsSource = m_subscription.EpisodesPublishedDescending; App.showNotificationToast("All episodes marked as listened."); } }