public void FromDevice(DriveInfo d, string device)
{
VolumeMonitor volmon = GLib.VolumeMonitor.Default;
// Search in mounts first
foreach (Mount m in volmon.Mounts) {
if ((m.Volume != null) && (m.Volume.GetIdentifier(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) == device)) {
FillDriveInfoFromMount(d, m, device);
return;
}
}
// Search in volumes (unmounted or else the device would have been found in volmon.Mounts)
foreach (Volume v in volmon.Volumes) {
if (v.GetIdentifier(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) == device) {
d.device = device;
d.driveType = GuessDriveType(null, v.Icon, v.Drive);
return;
}
}
// Search in drives (does not contain media or else the device
// would have been found in volmon.Mounts/Volumes) (e.g. cdrom-drives))
foreach (Drive dr in volmon.ConnectedDrives) {
if (dr.GetIdentifier(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) == device) {
d.device = device;
d.driveType = GuessDriveType(null, dr.Icon, dr);
return;
}
}
throw new ArgumentException("Can't find drive for specified device", "device");
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (this.IsBusy)
{
throw new InvalidOperationException("Scan in progress");
}
/*
* if (m_db != null)
* m_db.Close(); // TODO ? leavOpen in Scanworker.ctor after database parameter? PASS THIS leavOpen PARAMETER AT THE BufferedItemWriter INSTANCIATION AS WELL!!!
* m_media.Dispose(); // TODO ? (in case m_media implements IDisposable because of the MediaDB reference anytime later)
*/
}
drive = null;
database = null;
volume = null;
volumeInfo = null;
options = null;
asyncOperation = null;
disposed = true;
}
}
public static VolumeProbeResult ProbeVolume(PlatformIO.DriveInfo drive)
{
VolumeProbeResult result = VolumeProbeResult.Unknown;
if (drive == null)
{
throw new ArgumentNullException("drive");
}
if (!drive.IsReady)
{
throw new ArgumentException("Drive is not ready", "drive");
}
// check for audio cd first -
// win32 also mounts audio cds as filesystems
if (drive.HasAudioCdVolume)
{
return(VolumeProbeResult.AudioCd);
}
else if (drive.IsMounted)
{
return(VolumeProbeResult.Filesystem);
}
return(result);
}
public virtual void FromPath(DriveInfo d, string rootPath)
{
if (!rootPath.EndsWith("\\")) // e.g. "D:" -> "D:\"
rootPath += "\\";
// throws ArgumentException if drive can't be found
System.IO.DriveInfo di = new System.IO.DriveInfo(rootPath);
FillDriveInfo(d, di);
}
public DriveSelection()
{
BuildGui();
btnOk.Sensitive = false;
isDestroyed = false;
selectedDrive = null;
RefreshListAsync();
}
// note:
// do not allow to modify the constuctor parameters
// (i.e. database, options)
// through public properties later, since the scanner
// may already use them after scanning has been started,
// and some stuff has been initialized depending on the
// options in the ctor already.
public AudioCdVolumeScanner(Platform.Common.IO.DriveInfo drive,
VolumeDatabase database,
AudioCdScannerOptions options)
: base(drive, database, options)
{
if (!drive.HasAudioCdVolume)
{
throw new ArgumentException("No audio cd present in drive");
}
}
private static string GetLabel(DriveInfo d)
{
string label = d.VolumeLabel;
if (label.Length > 0)
return label;
else if(d.IsMounted && d.RootPath == "/")
return S._("Filesystem");
else
return "--";
}
public virtual List<DriveInfo> GetAll(bool readyDrivesOnly)
{
List<DriveInfo> drives = new List<DriveInfo>();
System.IO.DriveInfo[] ioDrives = System.IO.DriveInfo.GetDrives();
foreach (System.IO.DriveInfo di in ioDrives) {
if (!(readyDrivesOnly && !di.IsReady)) {
DriveInfo d = new DriveInfo();
FillDriveInfo(d, di);
drives.Add(d);
}
}
return drives;
}
// <summary>
/// Probes a volume, creates the appropriate VolumeScanner and returns a general interface to it.
/// </summary>
/// <param name="drive">Drive to be scanned</param>
/// <param name="database">VolumeDatabase object</param>
/// <param name="options">ScannerOptions for all possible scanners</param>
/// <returns>Interface to the proper VolumeScanner</returns>
public static IVolumeScanner GetScannerForVolume(PlatformIO.DriveInfo drive,
VolumeDatabase database,
ScannerOptions[] options)
{
if (drive == null)
{
throw new ArgumentNullException("drive");
}
if (!drive.IsReady)
{
throw new ArgumentException("Drive is not ready", "drive");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
IVolumeScanner scanner = null;
VolumeProbeResult result = ProbeVolume(drive);
switch (result)
{
case VolumeProbeResult.Filesystem:
scanner = new FilesystemVolumeScanner(drive,
database,
GetOptions <FilesystemScannerOptions>(options));
break;
case VolumeProbeResult.AudioCd:
scanner = new AudioCdVolumeScanner(drive,
database,
GetOptions <AudioCdScannerOptions>(options));
break;
case VolumeProbeResult.Unknown:
throw new ArgumentException("Volume is of an unknown type");
default:
throw new NotImplementedException(string.Format("VolumeProbeResult {0} is not implemented", result.ToString()));
}
return(scanner);
}
public void FromPath(DriveInfo d, string rootPath)
{
VolumeMonitor volmon = GLib.VolumeMonitor.Default;
// Remove endling slash from path
if ((rootPath.Length > 1) && (rootPath[rootPath.Length - 1] == System.IO.Path.DirectorySeparatorChar))
rootPath = rootPath.Substring(0, rootPath.Length - 1);
foreach (Mount m in volmon.Mounts) {
if (m.Root.Path == rootPath) {
FillDriveInfoFromMount (d, m,
(m.Volume != null) ? m.Volume.GetIdentifier (G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) : string.Empty);
return;
}
}
throw new ArgumentException("Can't find drive for specified path", "rootPath");
}
// note:
// do not allow to modify the constuctor parameters
// (i.e. database, options)
// through public properties later, since the scanner
// may already use them after scanning has been started,
// and some stuff has been initialized depending on the
// options in the ctor already.
internal AbstractVolumeScanner(PlatformIO.DriveInfo drive,
VolumeDatabase database,
TOpts options)
{
if (drive == null)
{
throw new ArgumentNullException("drive");
}
if (!drive.IsReady)
{
throw new ArgumentException("Drive is not ready", "drive");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
/* don't test database for null -- database is optional */
if ((options.BufferSize < 1) && (database != null))
{
throw new ArgumentOutOfRangeException("BufferSize");
}
this.isRunning = false;
//m_cancellationRequested = false;
this.scanSucceeded = false;
this.disposed = false;
this.drive = drive;
this.database = database;
// copy options reference so that they can't be modified
// while the scanner is running already.
this.options = new TOpts();
options.CopyTo(this.options);
this.itemID = VolumeDatabase.ID_NONE;
this.volume = CreateVolumeObject(drive, database, options.ComputeHashs);
this.volumeInfo = CreateInstance <TVolumeInfo>(volume);
}
/// <summary>
// Returns a specific Volume object, but preassigns properties of the Volume baseclass only.
// Filling properties of the specific, derived object, is job of the specific VolumeScanner implementation.
/// </summary>
private static TVolume CreateVolumeObject(PlatformIO.DriveInfo d,
VolumeDatabase database,
bool isHashed)
{
// TODO : check here whether everything is still filled correctly after media class reorganisation
long volumeID = VolumeDatabase.ID_NONE;
if (database != null)
{
// TODO : this is neither threadsave nor multi-instance save in general!
// maybe the db (physical db, VolumeDatabase object? this scanner?) should be locked during scanning?
volumeID = database.GetNextVolumeID();
}
TVolume v = CreateInstance <TVolume>(database);
// /* v = new TVolume(database); */
// v = (TVolume)VolumeDB.Volume.CreateInstance(volumeType, database);
//
// initialize fields of the Volume base class.
// don't initialize via properties. initializing via properties is error-prone
// as the compiler won't error if a new field is added to the base class
// and forgotten to be initialized here.
v.SetVolumeFields(
volumeID,
d.IsMounted ? d.VolumeLabel : string.Empty,
DateTime.Now,
/*di.VolumeSerialNumber,*/
isHashed,
volumeID.ToString(),
d.DriveType.ToVolumeDriveType(),
null,
DateTime.MinValue,
DateTime.MinValue,
null,
null,
null
);
return(v);
}
internal override void ScanningThreadMain(Platform.Common.IO.DriveInfo drive,
FileSystemVolume volume,
BufferedVolumeItemWriter writer)
{
try {
if (Options.GenerateThumbnails)
{
paths.volumeDataPath = DbData.CreateVolumeDataPath(paths.dbDataPath, volume.VolumeID);
paths.thumbnailPath = DbData.CreateVolumeDataThumbsPath(paths.volumeDataPath);
}
string rootPath = drive.RootPath;
// remove possible ending path seperator except for _system_ root paths
rootPath = RemoveEndingSlash(rootPath);
// if ((rootPath.Length > 1) && (rootPath[rootPath.Length - 1] == Path.DirectorySeparatorChar))
// rootPath = rootPath.Substring(0, rootPath.Length - 1);
// make sure the root path exists
// (media may have been removed after scanner construction)
if (!Directory.Exists(rootPath))
{
throw new DirectoryNotFoundException("Root path does not exist");
}
DirectoryInfo dir = new DirectoryInfo(rootPath);
RecursiveDump(rootPath, dir, writer, VolumeDatabase.ID_NONE);
symLinkHelper.InsertSymLinkItems(writer, volume.VolumeID);
volume.SetFileSystemVolumeFields(VolumeInfo.Files, VolumeInfo.Directories, VolumeInfo.Size);
} catch (Exception) {
// try to cleanup
try {
if ((paths.volumeDataPath != null) && Directory.Exists(paths.volumeDataPath))
{
Directory.Delete(paths.volumeDataPath, true);
}
} catch (Exception) { /* just shut up */ }
// rethrow initial exception
throw;
}
}
private static void FillDriveInfo(DriveInfo d, System.IO.DriveInfo di)
{
if (di.IsReady) {
d.volumeLabel = di.VolumeLabel;
d.totalSize = di.TotalSize;
d.filesystem = di.DriveFormat;
}
d.rootPath = di.RootDirectory.FullName;
// should return e.g. "D:", not "D:\"
d.device = d.rootPath[d.rootPath.Length - 1] == System.IO.Path.DirectorySeparatorChar ? d.rootPath.Substring(0, d.rootPath.Length - 1) : d.rootPath;
d.isMounted = true;
d.isReady = di.IsReady;
switch (di.DriveType) {
case System.IO.DriveType.CDRom:
d.driveType = DriveType.CDRom;
if (d.isReady)
d.hasAudioCdVolume = AudioCdWin32.IsAudioCd(d.device);
break;
case System.IO.DriveType.Fixed:
d.driveType = DriveType.Fixed;
break;
case System.IO.DriveType.Network:
d.driveType = DriveType.Network;
break;
case System.IO.DriveType.Ram:
d.driveType = DriveType.Ram;
break;
case System.IO.DriveType.Removable:
d.driveType = DriveType.Removable;
break;
case System.IO.DriveType.NoRootDirectory:
d.driveType = DriveType.Unknown;
d.isMounted = false;
break;
case System.IO.DriveType.Unknown:
d.driveType = DriveType.Unknown;
break;
}
}
// note:
// do not allow to modify the constuctor parameters
// (i.e. database, options)
// through public properties later, since the scanner
// may already use them after scanning has been started,
// and some stuff has been initialized depending on the
// options in the ctor already.
public FilesystemVolumeScanner(Platform.Common.IO.DriveInfo drive,
VolumeDatabase database,
FilesystemScannerOptions options)
: base(drive, database, options)
{
if (!drive.IsMounted)
{
throw new ArgumentException("Drive is not mounted", "drive");
}
if (Options.GenerateThumbnails && string.IsNullOrEmpty(Options.DbDataPath))
{
throw new ArgumentException("DbDataPath",
"Thumbnail generation requires the DbDataPath option to be set");
}
disposed = false;
//this.mimeInfo = new MimeInfo(false);
this.sbPathFixer = new StringBuilder(1024);
this.paths = new Paths(Options.DbDataPath, null, null);
this.symLinkHelper = new SymLinkHelper(this);
this.thumbGen = new ThumbnailGenerator();
}
// keep in sync with VolumeView.GetVolumeIcon()
public static Icons.Icon GetDriveIcon(DriveInfo d)
{
//// DriveInfo.DriveType is not supported on linux
//if (CurrentPlatform.IsUnix)
// return Stock.Harddisk;
Icons.Icon icon;
switch(d.DriveType) {
case DriveType.CDRom:
//name = Gtk.Stock.Cdrom;
icon = Icons.Icon.Stock_Cdrom;
break;
case DriveType.Fixed:
//name = Gtk.Stock.Harddisk;
icon = Icons.Icon.Stock_Harddisk;
break;
case DriveType.Ram:
//name = Gtk.Stock.Harddisk; // FIXME : is there a more suitable icon?
icon = Icons.Icon.Stock_Harddisk; // FIXME : is there a more suitable icon?
break;
case DriveType.Network:
//name = Gtk.Stock.Network;
icon = Icons.Icon.Stock_Network;
break;
case DriveType.Removable:
//name = "drive-removable-media";
icon = Icons.Icon.DriveRemovableMedia;
break;
case DriveType.Unknown:
//name = Gtk.Stock.Harddisk; // FIXME : is there a more suitable icon?
icon = Icons.Icon.Stock_Harddisk; // FIXME : is there a more suitable icon?
break;
default:
throw new Exception("Invalid DriveType.");
}
return icon;
}
private static void FillDriveInfoFromMount(DriveInfo d, GLib.Mount m, string device)
{
if (m.Volume != null) {
// Only get size and format info from physical volumes
// (System.IO.DriveInfo throws an exception on network mounts)
System.IO.DriveInfo di = new System.IO.DriveInfo (m.Root.Path);
d.totalSize = di.TotalSize;
d.filesystem = di.DriveFormat;
}
d.volumeLabel = m.Name;
d.rootPath = m.Root.Path;
d.device = device;
d.driveType = GuessDriveType(m.Root.UriScheme, m.Icon, m.Drive);
d.isMounted = true;
d.isReady = true;
d.hasAudioCdVolume = (m.Root.UriScheme == "cdda");
}
public static DriveInfo FromDevice(string device)
{
if (device == null)
throw new ArgumentNullException("device");
DriveInfo d = new DriveInfo();
dip.FromDevice(d, device);
return d;
}
internal override void ScanningThreadMain(PlatformIO.DriveInfo drive,
AudioCdVolume volume,
BufferedVolumeItemWriter writer)
{
if (Options.ComputeHashs)
{
SendScannerWarning(S._("Hashcode generation not implemented for audio cds yet."));
volume.IsHashed = false;
}
AudioCdRootVolumeItem root = GetNewVolumeItem <AudioCdRootVolumeItem>(VolumeDatabase.ID_NONE,
"/",
null,
MetadataStore.Empty,
VolumeItemType.AudioCdRootVolumeItem);
LocalDisc localdisc = LocalDisc.GetFromDevice(drive.Device);
if (localdisc == null)
{
throw new ApplicationException("Could not read contents of the audio cd");
}
TimeSpan[] durations = localdisc.GetTrackDurations();
List <AudioTrackVolumeItem> items = new List <AudioTrackVolumeItem>();
for (int i = 0; i < durations.Length; i++)
{
AudioTrackVolumeItem item = GetNewVolumeItem <AudioTrackVolumeItem>(root.ItemID,
"Track " + (i + 1),
MIME_TYPE_AUDIO_TRACK,
MetadataStore.Empty,
VolumeItemType.AudioTrackVolumeItem);
item.SetAudioTrackVolumeItemFields(durations[i]);
items.Add(item);
VolumeInfo.Tracks++;
VolumeInfo.Duration = VolumeInfo.Duration.Add(durations[i]);
}
// retrieve musicbrainz metadata
// (the metadata field of AudioTrackVolumeItems is set
// depending on the EnableMusicBrainz flag)
if (Options.EnableMusicBrainz)
{
try {
// may throw MusicBrainzNotFoundException
Release release = Release.Query(localdisc).PerfectMatch();
CheckForCancellationRequest();
if (release == null)
{
SendScannerWarning(S._("No MusicBrainz metadata available for this disc."));
}
else
{
var tracks = release.GetTracks();
if (tracks.Count != items.Count)
{
SendScannerWarning(S._("The trackcount retrieved from MusicBrainz does not match the trackcount of the local disc. Skipped."));
}
else
{
string albumTitle = release.GetTitle();
int releaseYear = GetReleaseYear(release);
for (int i = 0; i < tracks.Count; i++)
{
items[i].Name = tracks[i].GetTitle();
items[i].MetaData = GetMetadata(tracks[i], albumTitle, releaseYear);
}
volume.Title = albumTitle;
// preset category
ReleaseType rtype = release.GetReleaseType();
if (rtype == ReleaseType.Album ||
rtype == ReleaseType.EP ||
rtype == ReleaseType.Compilation ||
rtype == ReleaseType.Remix)
{
volume.Category = PRESELECTED_CATEGORY;
}
}
}
} catch (MusicBrainzNotFoundException) {
SendScannerWarning(S._("Error connecting to MusicBrainz server."));
}
}
volume.SetAudioCdVolumeFields(VolumeInfo.Tracks, VolumeInfo.Duration);
// write items
if (this.HasDB)
{
writer.Write(root);
foreach (AudioTrackVolumeItem item in items)
{
writer.Write(item);
}
}
}
public List<DriveInfo> GetAll(bool readyDrivesOnly)
{
List<DriveInfo> drives = new List<DriveInfo> ();
VolumeMonitor volmon = GLib.VolumeMonitor.Default;
foreach (Mount m in volmon.Mounts) {
DriveInfo d = new DriveInfo();
FillDriveInfoFromMount(d, m,
(m.Volume != null) ? m.Volume.GetIdentifier (G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) : string.Empty);
drives.Add(d);
}
if (!readyDrivesOnly) {
foreach (Volume v in volmon.Volumes) {
if (drives.FindIndex(di => (v.GetIdentifier(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE) == di.Device)) == -1) {
// Volume is unmounted or else it would have been referenced via volmon.Mounts
DriveInfo d = new DriveInfo();
d.device = v.GetIdentifier(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
d.driveType = GuessDriveType(null, v.Icon, v.Drive);
drives.Add(d);
}
}
foreach (Drive dr in volmon.ConnectedDrives) {
if (dr.IsMediaRemovable && !dr.HasMedia) {
DriveInfo d = new DriveInfo();
d.device = dr.GetIdentifier(G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
d.driveType = GuessDriveType(null, dr.Icon, dr);
drives.Add(d);
}
}
}
return drives;
}
private void ScanningThread(PlatformIO.DriveInfo drive,
TVolume volume,
BufferedVolumeItemWriter writer)
{
TVolume returnVolume = null;
Exception fatalError = null;
bool cancelled = false;
try {
if (this.HasDB)
{
Database.TransactionBegin(); // locks VolumeDatabase
}
ScanningThreadMain(drive, volume, writer);
if (this.HasDB)
{
writer.Close();
if (!volume.IsInserted)
{
volume.InsertIntoDB();
}
returnVolume = volume;
database.TransactionCommit(); // unlocks VolumeDatabase
}
//result = ScanningResult.Success;
scanSucceeded = true;
} catch (Exception ex) {
Exception rollbackException = null;
try {
// rollback all database changes
if (this.HasDB)
{
database.TransactionRollback(); // unlocks VolumeDatabase
}
} catch (Exception e) {
rollbackException = e;
}
if (ex is ScanCancelledException)
{
//result = ScanningResult.Cancelled;
cancelled = true;
}
else
{
//result = ScanningResult.FatalError;
/* save the error that caused the scanner to stop (scanning failure) */
fatalError = ex;
//OnError(new ErrorEventArgs(ex));
PostError(ex);
Debug.WriteLine("Details for exception in ScanningThread():\n" + ex.ToString());
}
// in case an error occured while rollig back,
// post the error here, _after_ the initial error that made the scan fail.
if (rollbackException != null)
{
//OnError(new ErrorEventArgs(rollbackException));
PostError(rollbackException);
}
//#if THROW_EXCEPTIONS_ON_ALL_THREADS
// if (!(ex is ScanCancelledException))
// throw;
//#endif
} finally {
/*
* TODO : unlock db / thread // (in try / catch / PostError !!) */
//if (result == ScanningResult.Success)
// m_scanSucceeded = true;
//m_cancellationRequested = false;
isRunning = false;
//try { OnScanCompleted(new ScanCompletedEventArgs(result, mediaID, fatalError)); }
//catch (Exception e) { OnError(new ErrorEventArgs(e)); }
PostCompleted(returnVolume, fatalError, cancelled);
}
}
abstract void ScanningThreadMain(PlatformIO.DriveInfo drive,
TVolume volume,
BufferedVolumeItemWriter writer);
public virtual void FromDevice(DriveInfo d, string device)
{
string rootPath = device; // FromPath() adds an ending slash ("d:\")
FromPath(d, rootPath); // throws ArgumentException if drive cant be found
}
private void OnTvDrivesSelectionChanged(object o, EventArgs args)
{
if (!IsListReady)
return;
TreeModel model;
TreeIter iter;
if (tvDrives.Selection.GetSelected(out model, out iter)) {
// enable ok button on first selection
if (selectedDrive == null)
btnOk.Sensitive = true;
selectedDrive = (DriveInfo)model.GetValue(iter, 4);
if (Global.EnableDebugging) {
Debug.WriteLine("selected drive '{0}'", selectedDrive.Device);
}
}
}
