public JamendoDownloadManager(string remote_uri, string mimetype)
{
this.mimetype = mimetype;
job = new DownloadManagerJob(this)
{
Title = AddinManager.CurrentLocalizer.GetString("Jamendo Downloads"),
Status = AddinManager.CurrentLocalizer.GetString("Contacting..."),
IconNames = new string [] { "jamendo" },
CanCancel = true
};
job.Finished += delegate { ServiceManager.SourceManager.MusicLibrary.NotifyUser(); };
ServiceManager.Get <JobScheduler> ().Add(job);
import_manager = new LibraryImportManager(true)
{
KeepUserJobHidden = true,
Debug = true,
Threaded = false
};
var downloader = new HttpFileDownloader()
{
Uri = new Uri(remote_uri),
TempPathRoot = Path.Combine(Path.GetTempPath(), "banshee-jamendo-downloader"),
FileExtension = mimetype == "application/zip" ? "zip" : "mp3"
};
job.CancelRequested += delegate { downloader.Abort(); };
QueueDownloader(downloader);
}
private void ProcessLibraryXml(LibraryImportManager import_manager, XmlReader xml_reader)
{
while (xml_reader.ReadToFollowing("key") && !CheckForCanceled())
{
xml_reader.Read();
string key = xml_reader.ReadContentAsString();
xml_reader.Read();
xml_reader.Read();
switch (key)
{
case "Music Folder":
if (!ProcessMusicFolderPath(xml_reader.ReadContentAsString()))
{
return;
}
break;
case "Tracks":
ProcessSongs(import_manager, xml_reader.ReadSubtree());
break;
case "Playlists":
if (data.get_playlists)
{
ProcessPlaylists(xml_reader.ReadSubtree());
}
break;
}
}
}
public AmazonDownloadManager(string path)
{
job = new DownloadManagerJob(this)
{
Title = Catalog.GetString("Amazon MP3 Purchases"),
Status = Catalog.GetString("Contacting..."),
IconNames = new string [] { "amazon-mp3-source" }
};
job.Finished += delegate { ServiceManager.SourceManager.MusicLibrary.NotifyUser(); };
ServiceManager.Get <JobScheduler> ().Add(job);
import_manager = new LibraryImportManager(true)
{
KeepUserJobHidden = true,
Debug = true,
Threaded = false
};
import_manager.ImportResult += OnImportManagerImportResult;
var playlist = new AmzXspfPlaylist(path);
foreach (var track in playlist.DownloadableTracks)
{
var downloader = new AmzMp3Downloader(track);
if (downloader.FileExtension == "mp3")
{
mp3_count++;
}
QueueDownloader(downloader);
}
}
public override void Import()
{
LibraryImportManager importer = new LibraryImportManager(true);
foreach (string audio_folder in BaseDirectories)
{
importer.Enqueue(audio_folder);
}
}
private void ProcessSongs(LibraryImportManager import_manager, XmlReader xml_reader)
{
using (xml_reader) {
xml_reader.ReadToFollowing("dict");
while (xml_reader.ReadToFollowing("dict") && !CheckForCanceled())
{
ProcessSong(import_manager, xml_reader.ReadSubtree());
}
}
}
public override void Import()
{
var importer = new LibraryImportManager(true)
{
SkipHiddenChildren = false
};
foreach (string audio_folder in BaseDirectories)
{
importer.Enqueue(audio_folder);
}
}
public SourceWatcher(LibrarySource library)
{
this.library = library;
handle = new ManualResetEvent(false);
string path = library.BaseDirectoryWithSeparator;
if (String.IsNullOrEmpty(path))
{
throw new Exception("Will not create LibraryWatcher for the blank directory");
}
string home = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + Path.DirectorySeparatorChar;
if (path == home)
{
throw new Exception("Will not create LibraryWatcher for the entire home directory");
}
string root = Path.GetPathRoot(Environment.CurrentDirectory);
if (path == root || path == root + Path.DirectorySeparatorChar)
{
throw new Exception("Will not create LibraryWatcher for the entire root directory");
}
if (!Banshee.IO.Directory.Exists(path))
{
throw new Exception("Will not create LibraryWatcher for non-existent directory");
}
import_manager = ServiceManager.Get <LibraryImportManager> ();
watcher = new FileSystemWatcher(path);
watcher.IncludeSubdirectories = true;
watcher.Changed += OnChanged;
watcher.Created += OnChanged;
watcher.Deleted += OnChanged;
watcher.Renamed += OnChanged;
active = true;
watch_thread = new Thread(new ThreadStart(Watch));
watch_thread.Name = String.Format("LibraryWatcher for {0}", library.Name);
watch_thread.IsBackground = true;
watch_thread.Start();
}
public void Initialize()
{
tasks = new Dictionary <string, HttpFileDownloadTask> ();
import_manager = new LibraryImportManager(true);
import_manager.ImportResult += HandleImportResult;
if (download_manager == null)
{
download_manager = new DownloadManager(2, tmp_download_path);
}
if (download_manager_iface == null)
{
download_manager_iface = new DownloadManagerInterface(download_manager);
download_manager_iface.Initialize();
}
ServiceManager.Get <DBusCommandService> ().ArgumentPushed += OnCommandLineArgument;
}
public void Initialize()
{
Log.DebugFormat("{0} initialized.", this.ToString());
tasks = new Dictionary <string, HttpFileDownloadTask> ();
import_manager = ServiceManager.Get <LibraryImportManager> ();
import_manager.ImportResult += HandleImportResult;
if (download_manager == null)
{
download_manager = new DownloadManager(2, tmp_download_path);
}
if (download_manager_iface == null)
{
download_manager_iface = new DownloadManagerInterface(download_manager);
download_manager_iface.Initialize();
}
ServiceManager.Get <DBusCommandService> ().ArgumentPushed += OnCommandLineArgument;
}
private void ProcessSong(LibraryImportManager import_manager, XmlReader xml_reader)
{
data.total_processed++;
var itunes_id = 0;
var title = String.Empty;
var title_sort = String.Empty;
var genre = String.Empty;
var artist = String.Empty;
var artist_sort = String.Empty;
var album_artist = String.Empty;
var album_artist_sort = String.Empty;
var composer = String.Empty;
var album = String.Empty;
var album_sort = String.Empty;
var grouping = String.Empty;
var year = 0;
var rating = 0;
var play_count = 0;
var track_number = 0;
var date_added = DateTime.Now;
var last_played = DateTime.MinValue;
SafeUri uri = null;
using (xml_reader) {
while (xml_reader.ReadToFollowing("key"))
{
xml_reader.Read();
string key = xml_reader.ReadContentAsString();
xml_reader.Read();
xml_reader.Read();
try {
switch (key)
{
case "Track ID":
itunes_id = Int32.Parse(xml_reader.ReadContentAsString());
break;
case "Name":
title = xml_reader.ReadContentAsString();
break;
case "Sort Name":
title_sort = xml_reader.ReadContentAsString();
break;
case "Genre":
genre = xml_reader.ReadContentAsString();
break;
case "Artist":
artist = xml_reader.ReadContentAsString();
break;
case "Sort Artist":
artist_sort = xml_reader.ReadContentAsString();
break;
case "Album Artist":
album_artist = xml_reader.ReadContentAsString();
break;
case "Sort Album Artist":
album_artist_sort = xml_reader.ReadContentAsString();
break;
case "Composer":
composer = xml_reader.ReadContentAsString();
break;
case "Album":
album = xml_reader.ReadContentAsString();
break;
case "Sort Album":
album_sort = xml_reader.ReadContentAsString();
break;
case "Grouping":
grouping = xml_reader.ReadContentAsString();
break;
case "Year":
year = Int32.Parse(xml_reader.ReadContentAsString());
break;
case "Rating":
rating = Int32.Parse(xml_reader.ReadContentAsString()) / 20;
break;
case "Play Count":
play_count = Int32.Parse(xml_reader.ReadContentAsString());
break;
case "Track Number":
track_number = Int32.Parse(xml_reader.ReadContentAsString());
break;
case "Date Added":
date_added = DateTime.Parse(xml_reader.ReadContentAsString(),
DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal);
break;
case "Play Date UTC":
last_played = DateTime.Parse(xml_reader.ReadContentAsString(),
DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeUniversal);
break;
case "Location":
uri = ConvertToLocalUri(xml_reader.ReadContentAsString());
break;
}
} catch {
}
}
}
if (uri == null)
{
return;
}
UpdateUserJob(data.total_processed, data.total_songs, artist, title);
try {
DatabaseTrackInfo track = import_manager.ImportTrack(uri);
if (track == null)
{
LogError(SafeUri.UriToFilename(uri), Catalog.GetString("Unable to import song."));
return;
}
if (!String.IsNullOrEmpty(title))
{
track.TrackTitle = title;
}
if (!String.IsNullOrEmpty(title_sort))
{
track.TrackTitleSort = title_sort;
}
if (!String.IsNullOrEmpty(artist))
{
track.ArtistName = artist;
}
if (!String.IsNullOrEmpty(artist_sort))
{
track.ArtistNameSort = artist_sort;
}
if (!String.IsNullOrEmpty(genre))
{
track.Genre = genre;
}
if (!String.IsNullOrEmpty(album_artist))
{
track.AlbumArtist = album_artist;
}
if (!String.IsNullOrEmpty(album_artist_sort))
{
track.AlbumArtistSort = album_artist_sort;
}
if (!String.IsNullOrEmpty(composer))
{
track.Composer = composer;
}
if (!String.IsNullOrEmpty(album))
{
track.AlbumTitle = album;
}
if (!String.IsNullOrEmpty(album_sort))
{
track.AlbumTitleSort = album_sort;
}
if (!String.IsNullOrEmpty(grouping))
{
track.Grouping = grouping;
}
if (year > 0)
{
track.Year = year;
}
if (data.get_ratings && rating > 0 && rating <= 5)
{
track.Rating = rating;
}
if (data.get_stats && play_count > 0)
{
track.PlayCount = play_count;
}
if (track_number > 0)
{
track.TrackNumber = track_number;
}
if (data.get_stats)
{
track.DateAdded = date_added;
}
if (data.get_stats && last_played > DateTime.MinValue)
{
track.LastPlayed = last_played;
}
data.track_ids.Add(itunes_id, track.TrackId);
track.Save(false);
} catch (Exception e) {
LogError(SafeUri.UriToFilename(uri), e);
}
}
public void Import()
{
LibraryImportManager importer = new LibraryImportManager(true);
importer.Enqueue(amazon_base_dir);
}
protected override void ImportCore()
{
LibraryImportManager import_manager = ServiceManager.Get <LibraryImportManager> ();
HyenaSqliteConnection conn;
try {
conn = new HyenaSqliteConnection(amarok_db_path);
} catch (Exception e) {
LogError(amarok_db_path, String.Format(
"Unable to open Amarok database: {0}", e.Message));
return;
}
int count = 0;
try {
count = conn.Query <int> ("SELECT COUNT(*) FROM tags");
} catch (Exception) {}
try {
HyenaSqliteCommand cmd = new HyenaSqliteCommand(@"
SELECT DISTINCT NULL,
tags.url,
tags.title,
artist.name,
genre.name,
album.name,
year.name,
tags.track,
tags.length
FROM tags,
artist,
album,
genre,
year
WHERE tags.deviceid = -1
AND tags.artist = artist.id
AND tags.album = album.id
AND tags.genre = genre.id
AND tags.year = year.id"
);
HyenaSqliteCommand stats_cmd = new HyenaSqliteCommand(@"
SELECT DISTINCT (rating+rating%2)/2, playcounter, createdate, accessdate
FROM statistics
WHERE url = ? AND deviceid = -1");
int processed = 0;
IDataReader reader = conn.Query(cmd);
while (reader.Read())
{
if (CheckForCanceled())
{
break;
}
processed++;
try {
string path = (string)reader[1];
SafeUri uri = null;
if (path.StartsWith("./"))
{
uri = new SafeUri(path.Substring(1));
}
else if (path.StartsWith("/"))
{
uri = new SafeUri(path);
}
else
{
continue;
}
string title = (string)reader[2];
string artist = (string)reader[3];
//Console.WriteLine ("Amarok import has {0}/{1} - {2}", artist, title, uri);
// the following fields are not critical and can be skipped if something goes wrong
int rating = 0, playcount = 0;
long created = 0, accessed = 0;
// Try to read stats
try {
IDataReader stats_reader = conn.Query(stats_cmd, path);
while (stats_reader.Read())
{
rating = Convert.ToInt32(stats_reader[0]);
playcount = Convert.ToInt32(stats_reader[1]);
created = Convert.ToInt64(stats_reader[2]);
accessed = Convert.ToInt64(stats_reader[3]);
}
stats_reader.Dispose();
} catch (Exception) {}
UpdateUserJob(processed, count, artist, title);
try {
DatabaseTrackInfo track = import_manager.ImportTrack(uri);
if (track == null)
{
throw new Exception(String.Format(Catalog.GetString("Unable to import track: {0}"), uri.AbsoluteUri));
}
if (rating > 0 || playcount > 0 || created > 0 || accessed > 0)
{
track.Rating = rating;
track.PlayCount = playcount;
if (created > 0)
{
track.DateAdded = Hyena.DateTimeUtil.FromTimeT(created);
}
if (accessed > 0)
{
track.LastPlayed = Hyena.DateTimeUtil.FromTimeT(accessed);
}
track.Save(false);
}
} catch (Exception e) {
LogError(SafeUri.UriToFilename(uri), e);
}
} catch (Exception e) {
Hyena.Log.Exception(e);
// something went wrong, skip entry
}
}
reader.Dispose();
import_manager.NotifyAllSources();
// TODO migrating more than the podcast subscriptions (eg whether to auto sync them etc) means 1) we need to have those features
// and 2) we need to depend on Migo and/or the Podcast extension
DBusCommandService cmd_service = ServiceManager.Get <DBusCommandService> ();
if (cmd_service != null && ServiceManager.DbConnection.TableExists("PodcastSyndications"))
{
foreach (string podcast_url in conn.QueryEnumerable <string> ("SELECT url FROM podcastchannels"))
{
cmd_service.PushFile(podcast_url.Replace("http:", "feed:"));
}
}
} catch (Exception e) {
Hyena.Log.Exception(e);
LogError(amarok_db_path, Catalog.GetString("Importing from Amarok failed"));
} finally {
conn.Dispose();
}
}
//private Stack<DatabaseTrackInfo> stk=new Stack<DatabaseTrackInfo>();
public void ImportSheet(CueSheet s)
{
if (import_manager == null)
{
try {
import_manager = new LibraryImportManager(false);
/*import_manager.ImportResult+=delegate(object sender,DatabaseImportResultArgs args) {
* DatabaseTrackInfo trk=args.Track;
* stk.Push (trk);
* };*/
} catch (Exception ex) {
Hyena.Log.Error(ex.ToString());
}
}
Hyena.Log.Debug("Importsheet: Starting transaction");
int i, N;
for (i = 0, N = s.nEntries(); i < N; i++)
{
try {
CueSheetEntry e = s.entry(i);
string file = e.file();
string uuid = Regex.Replace(e.id(), "\\s", "_");
string ext = ".mp3";
string uid = Guid.NewGuid().ToString();
string u1 = uid.Substring(0, 1);
string u2 = uid.Substring(0, 2);
string dir = basedir + "/.banshee/" + u1;
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
dir += "/" + u2;
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
uuid = dir + "/" + uuid + ext;
UnixFileInfo f = new UnixFileInfo(file);
if (File.Exists(uuid))
{
File.Delete(uuid);
}
//f.CreateLink (uuid);
f.CreateSymbolicLink(uuid);
DatabaseTrackInfo trk = import_manager.ImportTrack(uuid);
//File.Delete (uuid);
/*if (trk==null) {
* Hyena.Log.Warning ("track = null (file="+e.file ()+")");
* if (stk.Count>0) { trk=stk.Pop (); }
* }*/
if (trk == null)
{
Hyena.Log.Error("track = null (file=" + e.file() + ")");
}
else
{
Hyena.Log.Information("track!=null (file=" + e.file() + ")");
//MySource.DbConnection.BeginTransaction();
trk.PartOfCue = 1;
trk.CueAudioFile = e.file();
trk.AlbumTitle = s.title();
//trk.Album=s.title ();
trk.AlbumArtist = s.performer();
trk.Composer = (e.Composer == "") ? s.composer() : e.Composer;
//trk.ArtworkId=s.getArtId ();
//trk.Artist=
trk.ArtistName = (e.performer() == "") ? s.performer() : e.performer();
trk.TrackTitle = e.title();
trk.TrackNumber = i + 1;
trk.Genre = s.genre();
trk.BeginOffset = e.BeginOffset;
trk.EndOffset = e.EndOffset;
//trk.Uri=trk.CueAudioUri;
//trk.MediaAttributes = TrackMediaAttributes.ExternalResource;
//trk.PrimarySource = ServiceManager.SourceManager.MusicLibrary;
trk.Save();
//MySource.DbConnection.CommitTransaction();
}
} catch (Exception ex) {
Hyena.Log.Error(ex.ToString());
}
}
import_manager.NotifyAllSources();
}
protected override void ImportCore()
{
LibraryImportManager import_manager = ServiceManager.Get <LibraryImportManager> ();
SafeUri db_uri = rhythmbox_db_uri;
// Check if library is located in the old place (.gnome2/rhythmbox/rhythmdb.db)
if (!Banshee.IO.File.Exists(rhythmbox_db_uri))
{
db_uri = rhythmbox_db_uri_old;
}
if (!IsValidXmlDocument(db_uri))
{
LogError(SafeUri.UriToFilename(db_uri), "Rhythmbox library is corrupted.");
return;
}
// Load Rhythmbox library
Stream stream_db = Banshee.IO.File.OpenRead(db_uri);
XmlDocument xml_doc_db = new XmlDocument();
xml_doc_db.Load(stream_db);
XmlElement db_root = xml_doc_db.DocumentElement;
stream_db.Close();
if (db_root == null || !db_root.HasChildNodes || db_root.Name != "rhythmdb")
{
LogError(SafeUri.UriToFilename(db_uri), "Unable to open Rhythmbox library.");
return;
}
count = db_root.ChildNodes.Count;
processed = 0;
// Import Rhythmbox playlists if playlist file is available
SafeUri rhythmbox_playlists_uri = new SafeUri(Hyena.Paths.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Personal),
".local", "share", "rhythmbox", "playlists.xml"
));
bool playlists_available = Banshee.IO.File.Exists(rhythmbox_playlists_uri);
// Look at the old location too
if (!playlists_available)
{
rhythmbox_playlists_uri = new SafeUri(Hyena.Paths.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Personal),
".gnome2", "rhythmbox", "playlists.xml"
));
playlists_available = Banshee.IO.File.Exists(rhythmbox_playlists_uri);
}
XmlElement playlists_root = null;
if (playlists_available)
{
if (IsValidXmlDocument(rhythmbox_playlists_uri))
{
Stream stream_playlists = Banshee.IO.File.OpenRead(rhythmbox_playlists_uri);
XmlDocument xml_doc_playlists = new XmlDocument();
xml_doc_playlists.Load(stream_playlists);
playlists_root = xml_doc_playlists.DocumentElement;
stream_playlists.Close();
if (playlists_root == null || !playlists_root.HasChildNodes || playlists_root.Name != "rhythmdb-playlists")
{
playlists_available = false;
}
else
{
count += playlists_root.ChildNodes.Count;
}
}
else
{
LogError(SafeUri.UriToFilename(rhythmbox_playlists_uri), "Rhythmbox playlists are corrupted.");
playlists_available = false;
}
}
ImportSongs(import_manager, db_root.SelectNodes("/rhythmdb/entry[@type='song']"));
//ImportPodcasts (import_manager, db_root.SelectNodes ("/rhythmdb/entry[@type='podcast-post']"));
if (playlists_available)
{
ImportStaticPlaylists(playlists_root.SelectNodes("/rhythmdb-playlists/playlist[@type='static']"));
}
import_manager.NotifyAllSources();
}
private void ImportSongs(LibraryImportManager manager, XmlNodeList songs)
{
foreach (XmlElement song in songs)
{
if (CheckForCanceled())
{
break;
}
processed++;
string title = String.Empty,
genre = String.Empty,
artist = String.Empty,
album = String.Empty;
int year = 0,
rating = 0,
play_count = 0,
track_number = 0;
DateTime date_added = DateTime.Now,
last_played = DateTime.MinValue;
SafeUri uri = null;
foreach (XmlElement child in song.ChildNodes)
{
if (child == null || child.InnerText == null || child.InnerText == String.Empty)
{
continue;
}
try {
switch (child.Name)
{
case "title":
title = child.InnerText;
break;
case "genre":
genre = child.InnerText;
break;
case "artist":
artist = child.InnerText;
break;
case "album":
album = child.InnerText;
break;
case "track-number":
track_number = Int32.Parse(child.InnerText);
break;
case "location":
uri = new SafeUri(child.InnerText);
break;
case "date":
if (child.InnerText != "0")
{
year = (new DateTime(1, 1, 1).AddDays(Double.Parse(child.InnerText))).Year;
}
break;
case "rating":
rating = Int32.Parse(child.InnerText);
break;
case "play-count":
play_count = Int32.Parse(child.InnerText);
break;
case "last-played":
last_played = Hyena.DateTimeUtil.ToDateTime(Int64.Parse(child.InnerText));
break;
case "first-seen":
date_added = Hyena.DateTimeUtil.ToDateTime(Int64.Parse(child.InnerText));;
break;
}
} catch (Exception) {
// parsing InnerText failed
}
}
if (uri == null)
{
continue;
}
UpdateUserJob(processed, count, artist, title);
try {
DatabaseTrackInfo track = manager.ImportTrack(uri);
if (track == null)
{
LogError(SafeUri.UriToFilename(uri), Catalog.GetString("Unable to import song."));
continue;
}
track.TrackTitle = title;
track.ArtistName = artist;
track.Genre = genre;
track.AlbumTitle = album;
track.TrackNumber = track_number;
track.Year = year;
track.DateAdded = date_added;
track.Rating = (rating >= 0 && rating <= 5) ? rating : 0;
track.PlayCount = (play_count >= 0) ? play_count : 0;
track.LastPlayed = last_played;
track.Save(false);
} catch (Exception e) {
LogError(SafeUri.UriToFilename(uri), e);
}
}
}
