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);
}
public SourceWatcher (LibrarySource library)
{
this.library = library;
handle = new ManualResetEvent(false);
string path = library.BaseDirectoryWithSeparator;
string home = Environment.GetFolderPath (Environment.SpecialFolder.Personal) + Path.DirectorySeparatorChar;
if (path == home) {
throw new Exception ("Will not create LibraryWatcher for the entire home 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 SourceWatcher (LibrarySource library)
{
this.library = library;
handle = new ManualResetEvent(false);
string path = library.BaseDirectoryWithSeparator;
string home = Environment.GetFolderPath (Environment.SpecialFolder.Personal) + Path.DirectorySeparatorChar;
if (path == home) {
throw new Exception ("Will not create LibraryWatcher for the entire home directory");
}
import_manager = ServiceManager.Get<LibraryImportManager> ();
FileSystemWatcher master_watcher = new FileSystemWatcher (path);
master_watcher.IncludeSubdirectories = true;
master_watcher.Changed += OnChanged;
master_watcher.Created += OnChanged;
master_watcher.Deleted += OnChanged;
master_watcher.Renamed += OnChanged;
watcher.Add (master_watcher);
foreach (string additional_path in ServiceManager.SourceManager.ActiveSource.Properties.Get<string[]> ("AdditionalWatchedDirectories")) {
Hyena.Log.DebugFormat ("Watcher: additional LibraryWatcher for {0}", additional_path);
FileSystemWatcher additional_watcher = new FileSystemWatcher (additional_path);
additional_watcher.IncludeSubdirectories = true;
additional_watcher.Changed += OnChanged;
additional_watcher.Created += OnChanged;
additional_watcher.Deleted += OnChanged;
additional_watcher.Renamed += OnChanged;
watcher.Add (additional_watcher);
}
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 ();
}
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);
}
}
}
//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 ();
}
public override void Import ()
{
var importer = new LibraryImportManager (true) {
SkipHiddenChildren = false
};
foreach (string audio_folder in BaseDirectories) {
importer.Enqueue (audio_folder);
}
}
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);
}
}
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 ());
}
}
}
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 void Import()
{
LibraryImportManager importer = new LibraryImportManager (true);
importer.Enqueue (amazon_base_dir);
}
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 += OnModified;
watcher.Created += OnModified;
watcher.Deleted += OnModified;
watcher.Renamed += OnModified;
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;
}
