public ScannerArgument(DirectoryInfo directory, SearchOption searchoption,
bool parseAdd, bool parseUpdate, bool removeDeadFiles,
string[] extensions, RawTrack[] existingFiles)
: this(directory, searchoption, parseAdd, parseUpdate, removeDeadFiles,
extensions, existingFiles, new string[0])
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ScanFileEventArgs" /> class.
/// </summary>
/// <param name="filepath">The file path affected by the event.</param>
/// <param name="track">The track (if one exists) parsed from the file affected by the event.</param>
/// <param name="filestate">The file state affected by the event.</param>
public ScanFileEventArgs(long currentFileNumber, long totalFilesCount, string filepath, RawTrack track, FileState filestate)
{
_currentFileNumber = currentFileNumber;
_totalFilesCount = totalFilesCount;
_filepath = filepath;
_track = track;
_filestate = filestate;
}
/// <summary>
/// Initializes a new instance of the <see cref="ScanFileEventArgs" /> class.
/// </summary>
/// <param name="filepath">The file path affected by the event.</param>
/// <param name="track">The track (if one exists) parsed from the file affected by the event.</param>
/// <param name="filestate">The file state affected by the event.</param>
public ScanFileEventArgs(long currentFileNumber, long totalFilesCount, string filepath, RawTrack track, FileState filestate)
{
_currentFileNumber = currentFileNumber;
_totalFilesCount = totalFilesCount;
_filepath = filepath;
_track = track;
_filestate = filestate;
}
public void Load(RawTrack song)
{
lock (_playerLock)
{
_soundFile = _soundSystem.CreateSound(song.FullFilename);
_isLoaded = true;
}
}
public Track(RawTrack trackinfo, Album album, Artist artist)
{
_file = trackinfo.File;
Album = album;
Artist = artist;
Title = trackinfo.TrackTitle;
Tracknumber = trackinfo.TrackNumberUnknown ? (int?) null : trackinfo.TrackNumber;
Model = trackinfo;
}
private void LoadNewFile(string fileName, string pathToLibrary)
{
var raw = new RawTrack(fileName);
try
{
raw.LoadMetadata();
}
catch (UnsupportedFormatException)
{
return;
}
catch (TagLib.CorruptFileException)
{
return;
}
var track = new Track
{
BitRate = raw.BitRate,
Disc = raw.DiscNumber,
FileName = raw.FileName,
FileSize = raw.FileSize,
Duration = raw.Duration,
Number = raw.TrackNumber,
Title = raw.Title,
};
AddToNeededFolder(track, pathToLibrary);
database.Tracks.Add(track);
var album = FindExistingOrCreateNewAlbum
(
raw.AlbumTitle,
raw.AlbumYear,
raw.AlbumTrackCount,
raw.AlbumDiscCount,
raw.AlbumArt
);
album.Tracks.Add(track);
foreach (string artistName in raw.Artists)
{
FindExistingOrCreateNewArtist(artistName).Tracks.Add(track);
}
foreach (string artistName in raw.AlbumArtists)
{
FindExistingOrCreateNewArtist(artistName).Albums.Add(album);
}
foreach (string genreName in raw.AlbumGenres)
{
FindExistingOrCreateNewGenre(genreName).Albums.Add(album);
}
_ = raw;
}
/// <summary>
/// Reads metadata from a file to a <see cref="RawTrack" /> item. A return value indicates whether parsing succeeded.
/// The actual parsing is done using
/// <see
/// cref="ParseTrack(string)" />
/// .
/// </summary>
/// <param name="parser">
/// The <see cref="IDataParser" /> used for parsing metadata.
/// </param>
/// <param name="filepath">The full path of the file from which to read.</param>
/// <param name="item">
/// When the method returns, contains the read metadata, if parsing succeeded, or null if parsing failed. Parsing fails
/// if any exception is thrown from the
/// <see
/// cref="ParseTrack(string)" />
/// method. This parameter is passed uninitialized.
/// </param>
/// <returns>true if the file was parsed successfully; otherwise, false.</returns>
public static bool TryParseTrack(this IDataParser parser, string filepath, out RawTrack item)
{
try
{
item = parser.ParseTrack(filepath);
return item != null;
}
catch
{
item = null;
return false;
}
}
/// <summary>
/// Reads metadata from a file to a <see cref="RawTrack" /> item. A return value indicates whether parsing succeeded.
/// The actual parsing is done using
/// <see
/// cref="ParseTrack(string)" />
/// .
/// </summary>
/// <param name="parser">
/// The <see cref="IDataParser" /> used for parsing metadata.
/// </param>
/// <param name="filepath">The full path of the file from which to read.</param>
/// <param name="item">
/// When the method returns, contains the read metadata, if parsing succeeded, or null if parsing failed. Parsing fails
/// if any exception is thrown from the
/// <see
/// cref="ParseTrack(string)" />
/// method. This parameter is passed uninitialized.
/// </param>
/// <returns>true if the file was parsed successfully; otherwise, false.</returns>
public static bool TryParseTrack(this IDataParser parser, string filepath, out RawTrack item)
{
try
{
item = parser.ParseTrack(filepath);
return(item != null);
}
catch
{
item = null;
return(false);
}
}
public ScannerArgument(DirectoryInfo directory, SearchOption searchoption,
bool parseAdd, bool parseUpdate, bool removeDeadFiles,
string[] extensions, RawTrack[] existingFiles, string[] ignoredFiles)
{
this.directory = directory;
this.searchoption = searchoption;
this.parseAdd = parseAdd;
this.parseUpdate = parseUpdate;
this.removeDeadFiles = removeDeadFiles;
this.extensions = extensions;
this.existingFiles = existingFiles;
this.ignoredFiles = ignoredFiles;
this.tracer = new ScannerTracer();
}
public Track AddTrack(RawTrack track)
{
if (track == null)
throw new ArgumentNullException("track");
if (_trackDict.ContainsKey(track.FullFilename))
throw new ArgumentException(track.FullFilename + " is already in library - use Update instead.", "track");
Artist artist = _artists[track.ArtistName] ?? CreateArtist(track.ArtistName);
Album album = _albums[track.AlbumTitle] ?? CreateAlbum(track.AlbumTitle, track.Year);
var t = new Track(track, album, artist);
_tracks.Add(t);
album.Tracks.Add(t);
_trackDict.Add(track.FullFilename, t);
return t;
}
public Track UpdateTrack(RawTrack track)
{
Track old;
if (!_trackDict.TryGetValue(track.FullFilename, out old))
throw new ArgumentException(track.FullFilename + " was not found in library - use Add instead.", "track");
old.Title = track.TrackTitle;
old.Tracknumber = track.TrackNumberUnknown ? (int?) null : track.TrackNumber;
Album album = _albums[track.AlbumTitle] ?? CreateAlbum(track.AlbumTitle, track.Year);
if (album != old.Album)
{
old.Album.Tracks.Remove(old);
if (old.Album.Tracks.Count == 0)
_albums.Remove(old.Album);
old.Album = album;
album.Tracks.Add(old);
}
else
album.Tracks.Reposition(old);
Artist artist = _artists[track.ArtistName] ?? CreateArtist(track.ArtistName);
if (artist != old.Artist)
{
Artist oldArtist = old.Artist;
old.Artist = artist;
old.Album.Tracks.Remove(old);
old.Album.Tracks.Add(old);
if (oldArtist.Albums.Count == 0)
_artists.Remove(oldArtist);
}
return old;
}
private bool PathEqual(FileInfo x, RawTrack y)
{
return x.FullName.Equals(y.FullFilename);
}
private int ComparePath(FileInfo x, RawTrack y)
{
return String.Compare(x.FullName, y.FullFilename, StringComparison.Ordinal);
}
private void FileParsed(FileInfo filepath, RawTrack track, FileState state)
{
switch (state)
{
case FileState.Added:
_added++;
break;
case FileState.Updated:
_updated++;
break;
case FileState.AddError:
case FileState.UpdateError:
case FileState.Error:
_error++;
break;
case FileState.Removed:
_removed++;
break;
case FileState.Skipped:
_skipped++;
break;
default:
throw new InvalidOperationException("Unknown filestate.");
}
if (Parsed != null)
Parsed(this, new ScanFileEventArgs(_currentFile, _totalFiles, filepath.FullName, track, state));
}
public static bool ContainedInTitleArtistAlbum(RawTrack track, string searchstring)
{
return((track.TrackTitle != null && track.TrackTitle.ToLower().Contains(searchstring)) ||
(track.AlbumTitle != null && track.AlbumTitle.ToLower().Contains(searchstring)) ||
(track.ArtistName != null && track.ArtistName.ToLower().Contains(searchstring)));
}
private int ComparePath(RawTrack x, RawTrack y)
{
return x.FullFilename.CompareTo(y.FullFilename);
}
