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