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.");
}
}
