public void Reload()
{
model.Clear();
ThreadAssist.SpawnFromMain(delegate {
ThreadedFetch(0);
});
}
internal void TryClaim()
{
ThreadAssist.SpawnFromMain(() => {
if (TryDeviceInitialize())
{
LoadDeviceContents();
}
});
}
internal void TryInitialize ()
{
Log.DebugFormat ("PotentialSource: TryInitialize {0} as {1}", Device.Name, Claimant.Type);
ThreadAssist.SpawnFromMain (() => {
DapSource source;
if (TryDeviceInitialize (false, out source)) {
Service.SwapSource (this, source, false);
}
});
}
private void OnAddToNewPlaylist(object o, EventArgs args)
{
// TODO generate name based on the track selection, or begin editing it
PlaylistSource playlist = new PlaylistSource("New Playlist", ActivePrimarySource);
playlist.Save();
playlist.PrimarySource.AddChildSource(playlist);
ThreadAssist.SpawnFromMain(delegate {
playlist.AddSelectedTracks(ActiveSource);
});
}
public void LoadAndPresentRecommendations()
{
ThreadAssist.SpawnFromMain(() => {
recommended_artists = GetRecommendedArtists().ToList();
ThreadAssist.ProxyToMain(PresentRecommendedArtists);
var processor = new RecommendationProcessor(FillAdditionalInfo);
processor.EnqueueArtists(recommended_artists);
processor.ProcessAll();
});
}
protected override void DeleteSelectedTracks(DatabaseTrackListModel model)
{
if (model == null || model.Count < 1)
{
return;
}
ThreadAssist.SpawnFromMain(delegate {
CachedList <DatabaseTrackInfo> list = CachedList <DatabaseTrackInfo> .CreateFromModelSelection(model);
DeleteTrackList(list);
});
}
protected override void OnTracksAdded()
{
ThreadAssist.SpawnFromMain(delegate {
Reload();
TrackEventHandler handler = TracksAdded;
if (handler != null)
{
handler(this, new TrackEventArgs());
}
});
}
private void Initialize(Client client)
{
Application.ClientStarted -= Initialize;
var handler = Started;
if (handler != null)
{
handler();
}
Application.RunTimeout(5 * 1000, delegate {
if (BansheeMetrics.Instance == null)
{
return(false);
}
ThreadAssist.SpawnFromMain(delegate {
metrics.AddDefaults();
AddMetrics();
if (ApplicationContext.CommandLine.Contains("debug-metrics"))
{
Log.InformationFormat("Anonymous usage data collected:\n{0}", metrics.ToJsonString());
System.IO.File.WriteAllText("usage-data.json", metrics.ToJsonString());
}
if (!ServiceManager.Get <Network> ().Connected)
{
return;
}
// Don't post to server more than every 48 hours
var last_post_time = DatabaseConfigurationClient.Client.Get <DateTime> (last_post_key, DateTime.MinValue);
var last_post_rel = (DateTime.Now - last_post_time).TotalDays;
if (last_post_rel < 0 || last_post_rel > 4.0)
{
var poster = new HttpPoster("http://metrics.banshee.fm/submit/", metrics);
bool posted = poster.Post();
Log.InformationFormat("Posted usage data? {0}", posted);
// Clear the old metrics, even if we failed to post them; it might be a server-side
// problem w/ the data we want to send (eg too big, out of space) and we don't want
// to keep retrying to send the same data.
metrics.Store.Clear();
DatabaseConfigurationClient.Client.Set <DateTime> (last_post_key, DateTime.Now);
}
});
return(false);
});
}
public void Sync()
{
if (ThreadAssist.InMainThread)
{
ThreadAssist.SpawnFromMain(delegate {
sync_limiter.Execute();
});
}
else
{
sync_limiter.Execute();
}
}
public override void DeleteTracks(DatabaseTrackListModel model, Selection selection)
{
if (model == null || model.Count < 1)
{
return;
}
var list = CachedList <DatabaseTrackInfo> .CreateFromModelAndSelection(model, selection);
ThreadAssist.SpawnFromMain(delegate {
DeleteTrackList(list);
});
}
protected override void OnTracksDeleted()
{
ThreadAssist.SpawnFromMain(delegate {
PruneArtistsAlbums();
Reload();
TrackEventHandler handler = TracksDeleted;
if (handler != null)
{
handler(this, new TrackEventArgs());
}
SkipTrackIfRemoved();
});
}
private void OnRemoveTracks(object o, EventArgs args)
{
ITrackModelSource source = ActiveSource as ITrackModelSource;
if (!ConfirmRemove(source, false, source.TrackModel.Selection.Count))
{
return;
}
if (source != null && source.CanRemoveTracks)
{
ThreadAssist.SpawnFromMain(delegate {
source.RemoveSelectedTracks();
});
}
}
private static void OnUpdated(object o, ExtensionNodeEventArgs args)
{
TypeExtensionNode node = (TypeExtensionNode)args.ExtensionNode;
if (args.Change == ExtensionChange.Add)
{
provider = (BaseLocationProvider)node.CreateInstance();
ThreadAssist.SpawnFromMain(() => {
RefreshGeoPosition();
NotifyObservers();
});
}
else
{
provider = null;
}
}
public void SaveLyrics(TrackInfo track, string lyrics, bool rewrite)
{
if (!IsLyricsOk(lyrics))
{
/*update the db always */
LyricsManager.Instance.UpdateDB(track, lyrics);
return;
}
ThreadAssist.SpawnFromMain(delegate {
if (rewrite)
{
cache.DeleteLyrics(track);
}
Save(track, lyrics);
LyricsManager.Instance.UpdateDB(track, lyrics);
});
}
public void DeleteAllTracks(AbstractPlaylistSource source)
{
if (source.PrimarySource != this)
{
Log.WarningFormat("Cannot delete all tracks from {0} via primary source {1}", source, this);
return;
}
if (source.Count < 1)
{
return;
}
ThreadAssist.SpawnFromMain(delegate {
CachedList <DatabaseTrackInfo> list = CachedList <DatabaseTrackInfo> .CreateFromModel(source.DatabaseTrackModel);
DeleteTrackList(list);
});
}
/*
* Get the lyrics for the current track
*/
public void FetchLyrics(TrackInfo track)
{
string lyrics = null;
string error = null;
string suggestion = null;
LoadStarted(null, null);
ThreadAssist.SpawnFromMain(delegate {
try {
if (cache.IsInCache(track))
{
lyrics = cache.ReadLyrics(track);
}
else
{
lyrics = DownloadLyrics(track);
}
if (IsLyricsOk(lyrics))
{
Save(track, lyrics);
}
else
{
suggestion = GetSuggestions(track);
}
if (LyricOutOfDate(track))
{
return;
}
} catch (Exception e) {
Log.DebugException(e);
error = e.Message;
}
ThreadAssist.ProxyToMain(delegate {
LoadFinished(this, new LoadFinishedEventArgs(lyrics, suggestion, error));
});
});
}
private void OnRemoveTracksFromLibrary(object o, EventArgs args)
{
ITrackModelSource source = ActiveSource as ITrackModelSource;
if (source != null)
{
LibrarySource library = source.Parent as LibrarySource;
if (library != null)
{
if (!ConfirmRemove(library, false, Selection.Count))
{
return;
}
ThreadAssist.SpawnFromMain(delegate {
library.RemoveTracks(source.TrackModel as DatabaseTrackListModel, Selection);
});
}
}
}
/// <summary>
/// Catch PlayerEvent and schedule new lastfm query, as long as current Artist is not the last artist queried
/// </summary>
/// <param name="args">
/// A <see cref="PlayerEventArgs"/>
/// </param>
private static void OnPlayerEvent(PlayerEventArgs args)
{
DatabaseTrackInfo currentTrack = ServiceManager.PlayerEngine.CurrentTrack as DatabaseTrackInfo;
if (currentTrack == null)
{
return;
}
long currentArtistId = currentTrack.ArtistId;
if (ServiceManager.PlayerEngine.ActiveEngine.CurrentState == PlayerState.Playing && !processedArtists.Contains(currentArtistId))
{
if (!weightedRandom.Contains(currentArtistId))
{
// User changed Track to a not similar artist, clear list
Log.Debug("RandomByLastfmSimilarArtists: User changed track, clearing lists and resetting depth");
weightedRandom.Clear();
weightedRandom.Add(currentArtistId, 1d);
}
lock (searchActive_lock) {
if (searchActive)
{
Log.Debug("RandomByLastfmSimilarArtists: Another Query is already running, aborting");
return;
}
else
{
searchActive = true;
}
}
ThreadAssist.SpawnFromMain(delegate {
QueryLastfm();
lock (searchActive_lock) {
searchActive = false;
}
});
}
}
protected override void OnTracksChanged(params QueryField [] fields)
{
ThreadAssist.SpawnFromMain(delegate {
if (NeedsReloadWhenFieldsChanged(fields))
{
Reload();
}
else
{
InvalidateCaches();
}
System.Threading.Thread.Sleep(150);
TrackEventHandler handler = TracksChanged;
if (handler != null)
{
handler(this, new TrackEventArgs(fields));
}
});
}
public void FetchMore()
{
ThreadAssist.SpawnFromMain(delegate {
ThreadedFetch(search.Page + 1);
});
}
private void OnAddToExistingPlaylist(object o, EventArgs args)
{
ThreadAssist.SpawnFromMain(delegate {
((PlaylistMenuItem)o).Playlist.AddSelectedTracks(ActiveSource);
});
}
internal new void InvalidateCaches()
{
ThreadAssist.SpawnFromMain(delegate {
base.InvalidateCaches();
});
}
protected virtual void OnTransferStateChanged(object sender, TransferEventArgs args)
{
Log.DebugFormat("OnTransferStateChanged: {0}", args.State.ToString());
switch (args.State)
{
case TransferState.Queued:
total++;
break;
case TransferState.Ready:
ThreadAssist.SpawnFromMain(delegate {
StartReady();
});
break;
case TransferState.InProgress:
bytes_expected += args.BytesExpected;
in_progress++;
break;
case TransferState.Completed:
case TransferState.Cancelled:
case TransferState.Failed:
T t = sender as T;
CleanUpTransfer(t);
bool start = true;
if (args.State == TransferState.Completed)
{
OnTransferCompleted(t, EventArgs.Empty);
}
else if (args.State == TransferState.Cancelled && args.BytesTransferred == 0)
{
start = false;
}
else if ((args.State == TransferState.Cancelled || args.State == TransferState.Failed) && args.BytesTransferred > 0)
{
bytes_expected -= args.BytesExpected;
bytes_transferred -= args.BytesTransferred;
}
if (args.BytesTransferred > 0)
{
in_progress--;
}
if (initiated.Contains(t.Key))
{
initiated.Remove(t.Key);
}
total--;
if (start)
{
ThreadAssist.SpawnFromMain(delegate {
StartReady();
});
}
break;
}
OnUpdated();
if (in_progress == 0 && total == 0)
{
bytes_expected = 0;
bytes_transferred = 0;
OnCompleted(EventArgs.Empty);
}
}
private void Load()
{
ThreadAssist.SpawnFromMain(ThreadedLoad);
}
public override void LoadPath(string path, string suggestedFilename, System.Action finishedCallback)
{
lock (this) {
// One document per window
if (loading || Document != null)
{
new Client().LoadPath(path, suggestedFilename);
return;
}
loading = true;
}
if (!path.StartsWith("file://"))
{
path = System.IO.Path.GetFullPath(path);
}
Configuration.LastOpenFolder = System.IO.Path.GetDirectoryName(suggestedFilename ?? path);
status_label.Text = Catalog.GetString("Loading document...");
ThreadAssist.SpawnFromMain(delegate {
try {
Document = new Document();
Document.Load(path, PasswordProvider, suggestedFilename != null);
if (suggestedFilename != null)
{
Document.SuggestedSavePath = suggestedFilename;
}
ThreadAssist.BlockingProxyToMain(delegate {
IconView.SetDocument(Document);
BookmarkView.SetDocument(Document);
RecentManager.Default.AddItem(Document.Uri);
Document.Changed += UpdateForDocument;
UpdateForDocument();
OnDocumentLoaded();
});
} catch (Exception e) {
Document = null;
ThreadAssist.BlockingProxyToMain(delegate {
status_label.Text = "";
if (e is System.IO.FileNotFoundException)
{
try {
RecentManager.Default.RemoveItem(new Uri(path).AbsoluteUri);
} catch {}
}
});
Hyena.Log.Exception(e);
Hyena.Log.Error(
Catalog.GetString("Error Loading Document"),
String.Format(Catalog.GetString("There was an error loading {0}"), GLib.Markup.EscapeText(path ?? "")), true
);
} finally {
lock (this) {
loading = false;
}
if (finishedCallback != null)
{
finishedCallback();
}
}
});
}
public void DelayedInitialize()
{
ThreadAssist.SpawnFromMain(ThreadedInitialize);
}
private void HandleSelectionChanged(object sender, EventArgs args)
{
ThreadAssist.SpawnFromMain(ReloadBrowsingModel);
}
internal void UnmapDevice(string uuid)
{
ThreadAssist.SpawnFromMain(() => Unmap(uuid));
}
// FIXME filter
private void OnRateSelectedTracks(object o, EventArgs args)
{
ThreadAssist.SpawnFromMain(delegate {
((DatabaseSource)ActiveSource).RateSelectedTracks(selected_tracks_rating_proxy.LastRating);
});
}
public void DelayedInitialize()
{
download_manager = new DownloadManager(2, tmp_download_path);
download_manager_iface = new DownloadManagerInterface(download_manager);
download_manager_iface.Initialize();
feeds_manager = new FeedsManager(ServiceManager.DbConnection, download_manager, null);
// Migrate data from 0.13.2 podcast tables, if they exist
MigrateLegacyIfNeeded();
// Move incomplete downloads to the new cache location
try {
MigrateDownloadCache();
} catch (Exception e) {
Hyena.Log.Exception("Couldn't migrate podcast download cache", e);
}
source = new PodcastSource();
ServiceManager.SourceManager.AddSource(source);
InitializeInterface();
var preference = source.PreferencesPage["library-location"]["library-location"] as SchemaPreference <string>;
preference.ValueChanged += delegate(Root obj) {
feeds_manager.PodcastStorageDirectory = preference.Value;
};
ThreadAssist.SpawnFromMain(delegate {
feeds_manager.PodcastStorageDirectory = source.BaseDirectory;
feeds_manager.FeedManager.ItemAdded += OnItemAdded;
feeds_manager.FeedManager.ItemChanged += OnItemChanged;
feeds_manager.FeedManager.ItemRemoved += OnItemRemoved;
feeds_manager.FeedManager.FeedsChanged += OnFeedsChanged;
if (DatabaseConfigurationClient.Client.Get <int> ("Podcast", "Version", 0) < 7)
{
Banshee.Library.LibrarySource music_lib = ServiceManager.SourceManager.MusicLibrary;
if (music_lib != null)
{
string old_path = Path.Combine(music_lib.BaseDirectory, "Podcasts");
string new_path = source.BaseDirectory;
SafeUri old_uri = new SafeUri(old_path);
SafeUri new_uri = new SafeUri(new_path);
if (old_path != null && new_path != null && old_path != new_path &&
Banshee.IO.Directory.Exists(old_path) && !Banshee.IO.Directory.Exists(new_path))
{
Banshee.IO.Directory.Move(new SafeUri(old_path), new SafeUri(new_path));
ServiceManager.DbConnection.Execute(String.Format(
"UPDATE {0} SET LocalPath = REPLACE(LocalPath, ?, ?) WHERE LocalPath IS NOT NULL",
FeedEnclosure.Provider.TableName), old_path, new_path);
ServiceManager.DbConnection.Execute(String.Format(
"UPDATE CoreTracks SET Uri = REPLACE ({0}, ?, ?)" +
"WHERE {0} LIKE 'file://%' AND PrimarySourceId = ?",
Banshee.Query.BansheeQuery.UriField.Column),
old_uri.AbsoluteUri, new_uri.AbsoluteUri, source.DbId);
Hyena.Log.DebugFormat("Moved Podcasts from {0} to {1}", old_path, new_path);
}
}
DatabaseConfigurationClient.Client.Set <int> ("Podcast", "Version", 7);
}
ServiceManager.PlayerEngine.ConnectEvent(OnPlayerEvent, PlayerEvent.StateChange);
ServiceManager.Get <DBusCommandService> ().ArgumentPushed += OnCommandLineArgument;
RefreshFeeds();
// Every 10 minutes try to refresh again
refresh_timeout_id = Application.RunTimeout(1000 * 60 * 10, RefreshFeeds);
ServiceManager.Get <Network> ().StateChanged += OnNetworkStateChanged;
});
source.UpdateFeedMessages();
}
