public IEnumerable <LibraryItem> GetItems(LibraryHierarchyNode libraryHierarchyNode, bool loadMetaData)
{
using (var database = this.DatabaseFactory.Create())
{
using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel))
{
var items = database.ExecuteEnumerator <LibraryItem>(database.Queries.GetLibraryItems(this.Filter), (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["libraryHierarchyId"] = libraryHierarchyNode.LibraryHierarchyId;
parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id;
parameters["loadMetaData"] = loadMetaData;
parameters["metaDataType"] = META_DATA_TYPE;
break;
}
}, transaction);
foreach (var item in items)
{
item.InitializeComponent(this.Core);
yield return(item);
}
}
}
}
protected virtual async Task AddPlaylistItems(LibraryHierarchyNode libraryHierarchyNode, string filter)
{
using (var task = new SingletonReentrantTask(this, ComponentSlots.Database, SingletonReentrantTask.PRIORITY_HIGH, async cancellationToken =>
{
using (var transaction = this.Database.BeginTransaction(this.Database.PreferredIsolationLevel))
{
this.Offset = await this.Database.ExecuteScalarAsync <int>(this.Database.Queries.AddLibraryHierarchyNodeToPlaylist(filter, this.Sort.Value), (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["playlistId"] = this.Playlist.Id;
parameters["libraryHierarchyId"] = libraryHierarchyNode.LibraryHierarchyId;
parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id;
parameters["sequence"] = this.Sequence;
parameters["status"] = PlaylistItemStatus.Import;
break;
}
}, transaction).ConfigureAwait(false);
transaction.Commit();
}
}))
{
await task.Run().ConfigureAwait(false);
}
}
protected virtual IEnumerable <LibraryHierarchyNode> GetNodesCore(LibraryHierarchyNode libraryHierarchyNode, string filter)
{
using (var database = this.DatabaseFactory.Create())
{
using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel))
{
var nodes = database.ExecuteEnumerator <LibraryHierarchyNode>(database.Queries.GetLibraryHierarchyNodes(filter), (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["libraryHierarchyId"] = libraryHierarchyNode.LibraryHierarchyId;
parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id;
break;
}
}, transaction);
foreach (var node in nodes)
{
node.Parent = libraryHierarchyNode;
node.InitializeComponent(this.Core);
yield return(node);
}
}
}
}
private void DrawImage(LibraryHierarchyNode libraryHierarchyNode, DrawingContext context, int position, int count, int width, int height)
{
var id = this.GetImageId(libraryHierarchyNode, width, height) + position;
var fileName = libraryHierarchyNode.MetaDatas[position].Value;
if (!File.Exists(fileName))
{
return;
}
var region = this.GetRegion(context, position, count, width, height);
var size = (int)Math.Max(region.Width, region.Height);
var source = this.ImageLoader.Load(id, fileName, size, size, false);
if (source == null)
{
//Image failed to load, nothing can be done.
return;
}
if (region.Width != region.Height)
{
source = this.CropImage(source, region, width, height);
source.Freeze();
}
context.DrawImage(source, region);
}
public LibraryHierarchyNode GetNode(LibraryHierarchy libraryHierarchy, LibraryHierarchyNode libraryHierarchyNode)
{
var libraryHierarchyNodes = new List <LibraryHierarchyNode>()
{
libraryHierarchyNode
};
while (libraryHierarchyNode.Parent != null)
{
libraryHierarchyNodes.Insert(0, libraryHierarchyNode.Parent);
libraryHierarchyNode = libraryHierarchyNode.Parent;
}
for (var a = 0; a < libraryHierarchyNodes.Count; a++)
{
if (a == 0)
{
libraryHierarchyNodes[a] = this.GetNodes(libraryHierarchy).Find(libraryHierarchyNodes[a]);
}
else
{
libraryHierarchyNodes[a] = this.GetNodes(libraryHierarchyNodes[a - 1]).Find(libraryHierarchyNodes[a]);
}
libraryHierarchyNode = libraryHierarchyNodes[a];
if (libraryHierarchyNode == null)
{
//A node failed to refresh, cannot continue as we don't know what the new parent is.
return(null);
}
}
return(libraryHierarchyNode);
}
public Task Add(Playlist playlist, LibraryHierarchyNode libraryHierarchyNode, bool clear)
{
Logger.Write(this, LogLevel.Debug, "Adding library node to playlist.");
var index = this.PlaylistBrowser.GetInsertIndex(this.SelectedPlaylist);
return(this.Insert(playlist, index, libraryHierarchyNode, clear));
}
private IDatabaseReader GetReader(IDatabaseComponent database, LibraryHierarchyNode libraryHierarchyNode, MetaDataItemType?metaDataItemType, string metaDataItemName, ITransactionSource transaction)
{
return(database.ExecuteReader(database.Queries.GetLibraryHierarchyMetaData(this.LibraryHierarchyBrowser.Filter), (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id;
if (metaDataItemType.HasValue)
{
parameters["type"] = metaDataItemType.Value;
}
else
{
parameters["type"] = null;
}
if (!string.IsNullOrEmpty(metaDataItemName))
{
parameters["name"] = metaDataItemName;
}
else
{
parameters["name"] = null;
}
break;
}
}, transaction));
}
public ImageSource CreateImageSource(LibraryHierarchyNode libraryHierarchyNode, int width, int height, bool cache)
{
try
{
var id = this.GetImageId(libraryHierarchyNode, width, height);
if (cache)
{
var fileName = default(string);
if (FileMetaDataStore.Exists(PREFIX, id, out fileName))
{
return(this.ImageLoader.Load(fileName, 0, 0, true));
}
}
using (KeyLock.Lock(id))
{
if (cache)
{
var fileName = default(string);
if (FileMetaDataStore.Exists(PREFIX, id, out fileName))
{
return(this.ImageLoader.Load(fileName, 0, 0, true));
}
}
return(this.CreateImageSourceCore(libraryHierarchyNode, width, height, cache));
}
}
catch (Exception e)
{
Logger.Write(this, LogLevel.Error, "Error creating image source: {0}", e.Message);
return(null);
}
}
public IEnumerable <MetaDataItem> GetMetaDatas(LibraryHierarchyNode libraryHierarchyNode, MetaDataItemType metaDataItemType)
{
using (var database = this.DatabaseFactory.Create())
{
using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel))
{
using (var reader = database.ExecuteReader(database.Queries.GetLibraryHierarchyMetaData, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id;
parameters["type"] = metaDataItemType;
break;
}
}, transaction))
{
foreach (var record in reader)
{
yield return(new MetaDataItem()
{
Value = record.Get <string>("Value")
});
}
}
}
}
}
protected virtual async Task GetRating(LibraryHierarchyNode libraryHierarchyNode, Dictionary <byte, InvocationComponent> invocationComponents)
{
Logger.Write(this, LogLevel.Debug, "Determining rating for library hierarchy node: {0}", libraryHierarchyNode.Id);
var rating = default(byte);
var ratings = await this.MetaDataBrowser.GetMetaDatasAsync(libraryHierarchyNode, MetaDataItemType.Tag, CommonStatistics.Rating).ConfigureAwait(false);
switch (ratings.Length)
{
case 0:
Logger.Write(this, LogLevel.Debug, "Library hierarchy node {0} tracks have no rating.", libraryHierarchyNode.Id);
rating = 0;
break;
case 1:
if (!byte.TryParse(ratings[0].Value, out rating))
{
Logger.Write(this, LogLevel.Warn, "Library hierarchy node {0} tracks have rating \"{1}\" which is in an unknown format.", libraryHierarchyNode.Id, rating);
return;
}
Logger.Write(this, LogLevel.Debug, "Library hierarchy node {0} tracks have rating {1}.", libraryHierarchyNode.Id, rating);
break;
default:
Logger.Write(this, LogLevel.Debug, "Library hierarchy node {0} tracks have multiple ratings.", libraryHierarchyNode.Id);
return;
}
foreach (var key in invocationComponents.Keys)
{
var invocationComponent = invocationComponents[key];
if (key == rating)
{
invocationComponent.Attributes = (byte)(invocationComponent.Attributes | InvocationComponent.ATTRIBUTE_SELECTED);
}
}
}
private ImageSource CreateImageSourceCore(LibraryHierarchyNode libraryHierarchyNode, int width, int height, bool cache)
{
var fileNames = libraryHierarchyNode.MetaDatas.Where(
metaDataItem => metaDataItem.Type == MetaDataItemType.Image && File.Exists(metaDataItem.Value)
).Select(
metaDataItem => metaDataItem.Value
).ToArray();
switch (this.ImageMode)
{
case LibraryBrowserImageMode.First:
switch (fileNames.Length)
{
case 0:
return null;
default:
return this.CreateImageSource1(libraryHierarchyNode, fileNames, width, height);
}
default:
case LibraryBrowserImageMode.Compound:
switch (fileNames.Length)
{
case 0:
return null;
case 1:
return this.CreateImageSource1(libraryHierarchyNode, fileNames, width, height);
case 2:
return this.CreateImageSource2(libraryHierarchyNode, fileNames, width, height, cache);
case 3:
return this.CreateImageSource3(libraryHierarchyNode, fileNames, width, height, cache);
default:
return this.CreateImageSource4(libraryHierarchyNode, fileNames, width, height, cache);
}
}
}
public AsyncResult <ImageBrush> Create(LibraryHierarchyNode libraryHierarchyNode)
{
if (libraryHierarchyNode == null)
{
return(AsyncResult <ImageBrush> .FromValue(this.FallbackValue.Value));
}
var cache = string.IsNullOrEmpty(this.LibraryHierarchyBrowser.Filter);
if (cache)
{
var brush = default(ImageBrush);
if (this.Store.TryGetValue(libraryHierarchyNode, out brush))
{
return(AsyncResult <ImageBrush> .FromValue(brush));
}
}
if (this.Width != this.TileSize.Value || this.Height != this.TileSize.Value)
{
this.CalculateTileSize(this.TileSize.Value, this.TileSize.Value);
}
return(new AsyncResult <ImageBrush>(this.FallbackValue.Value, this.Factory.StartNew(() =>
{
if (cache)
{
return this.Store.GetOrAdd(
libraryHierarchyNode,
() => this.Create(libraryHierarchyNode, true)
);
}
else
{
return this.Create(libraryHierarchyNode, false);
}
})));
}
public async Task Add(LibraryHierarchyNode libraryHierarchyNode, bool clear)
{
Logger.Write(this, LogLevel.Debug, "Adding library node to playlist.");
var index = await this.PlaylistBrowser.GetInsertIndex().ConfigureAwait(false);
await this.Insert(index, libraryHierarchyNode, clear).ConfigureAwait(false);
}
private async Task <IEnumerable <MetaDataItem> > GetMetaDatasCoreAsync(LibraryHierarchyNode libraryHierarchyNode, MetaDataItemType?metaDataItemType, string metaDataItemName)
{
using (var database = this.DatabaseFactory.Create())
{
using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel))
{
using (var reader = this.GetReader(database, libraryHierarchyNode, metaDataItemType, metaDataItemName, transaction))
{
using (var sequence = reader.GetAsyncEnumerator())
{
var result = new List <MetaDataItem>();
while (await sequence.MoveNextAsync().ConfigureAwait(false))
{
result.Add(new MetaDataItem()
{
Name = metaDataItemName,
Type = metaDataItemType.GetValueOrDefault(),
Value = sequence.Current.Get <string>("Value")
});
}
return(result);
}
}
}
}
}
private IEnumerable <LibraryHierarchyNode> GetNodesCore(LibraryHierarchyNode libraryHierarchyNode)
{
foreach (var child in this.GetNodes(libraryHierarchyNode.LibraryHierarchyId, libraryHierarchyNode.Id))
{
child.Parent = libraryHierarchyNode;
yield return(child);
}
}
public async Task SetRating(LibraryHierarchyNode libraryHierarchyNode, byte rating)
{
using (var task = new UpdateLibraryRatingTask(libraryHierarchyNode, rating))
{
task.InitializeComponent(this.Core);
await this.OnBackgroundTask(task).ConfigureAwait(false);
await task.Run().ConfigureAwait(false);
}
}
public Task SetRating(LibraryHierarchyNode libraryHierarchyNode, byte rating)
{
//TODO: Warning: Buffering a potentially large sequence. It might be better to run the query multiple times.
var libraryItems = this.LibraryHierarchyBrowser.GetItems(
libraryHierarchyNode,
true
).ToArray();
return(this.SetRating(libraryItems, rating));
}
public async Task Add(Playlist playlist, LibraryHierarchyNode libraryHierarchyNode)
{
using (var task = new AddPlaylistTask(playlist, libraryHierarchyNode))
{
task.InitializeComponent(this.Core);
await this.OnBackgroundTask(task).ConfigureAwait(false);
await task.Run().ConfigureAwait(false);
}
}
private ImageSource CreateImageSource2(LibraryHierarchyNode libraryHierarchyNode, string[] fileNames, int width, int height, bool cache)
{
var visual = new DrawingVisual();
using (var context = visual.RenderOpen())
{
this.DrawImage(fileNames[0], context, 0, 2, width, height);
this.DrawImage(fileNames[1], context, 1, 2, width, height);
}
return this.Render(libraryHierarchyNode, visual, width, height, cache);
}
private ImageSource CreateImageSource1(LibraryHierarchyNode libraryHierarchyNode, int width, int height)
{
var id = this.GetImageId(libraryHierarchyNode, width, height);
var fileName = libraryHierarchyNode.MetaDatas[0].Value;
if (!File.Exists(fileName))
{
return(this.CreateImageSource0(libraryHierarchyNode, width, height));
}
return(this.ImageLoader.Load(id, fileName, width, height, true));
}
private string GetImageId(LibraryHierarchyNode libraryHierarchyNode, int width, int height)
{
var hashCode = default(int);
unchecked
{
hashCode = (hashCode * 29) + libraryHierarchyNode.Id.GetHashCode();
hashCode = (hashCode * 29) + width.GetHashCode();
hashCode = (hashCode * 29) + height.GetHashCode();
}
return Math.Abs(hashCode).ToString();
}
private ImageSource CreateImageSource2(LibraryHierarchyNode libraryHierarchyNode, int width, int height)
{
var visual = new DrawingVisual();
using (var context = visual.RenderOpen())
{
this.DrawImage(libraryHierarchyNode, context, 0, 2, width, height);
this.DrawImage(libraryHierarchyNode, context, 1, 2, width, height);
}
return(this.Render(libraryHierarchyNode, visual, width, height));
}
public async Task Insert(Playlist playlist, int index, LibraryHierarchyNode libraryHierarchyNode, bool clear)
{
Logger.Write(this, LogLevel.Debug, "Inserting library node into playlist at index: {0}", index);
using (var task = new AddLibraryHierarchyNodeToPlaylistTask(playlist, index, libraryHierarchyNode, clear))
{
task.InitializeComponent(this.Core);
await this.OnBackgroundTask(task).ConfigureAwait(false);
await task.Run().ConfigureAwait(false);
}
}
public async Task AddPlaylist(LibraryHierarchyNode libraryHierarchyNode)
{
var playlist = new Playlist()
{
Name = libraryHierarchyNode.Value,
Enabled = true
};
await this.PlaylistManager.Add(playlist, libraryHierarchyNode).ConfigureAwait(false);
this.PlaylistManager.SelectedPlaylist = playlist;
}
private async Task AddPlaylistItems(IDatabaseQuery query, LibraryHierarchyNode libraryHierarchyNode, ITransactionSource transaction)
{
this.Offset += await this.Database.ExecuteScalarAsync <int>(query, (parameters, phase) =>
{
switch (phase)
{
case DatabaseParameterPhase.Fetch:
parameters["libraryHierarchyId"] = libraryHierarchyNode.LibraryHierarchyId;
parameters["libraryHierarchyItemId"] = libraryHierarchyNode.Id;
parameters["sequence"] = this.Sequence;
parameters["status"] = PlaylistItemStatus.Import;
break;
}
}, transaction).ConfigureAwait(false);
}
private ImageSource Render(LibraryHierarchyNode libraryHierarchyNode, DrawingVisual visual, int width, int height)
{
var target = new RenderTargetBitmap(width, height, DPIX, DPIY, PixelFormats.Pbgra32);
target.Render(visual);
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(target));
using (var stream = new MemoryStream())
{
encoder.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
FileMetaDataStore.Write(PREFIX, this.GetImageId(libraryHierarchyNode, width, height), stream);
stream.Seek(0, SeekOrigin.Begin);
}
target.Freeze();
return(target);
}
public ImageSource CreateImageSource(LibraryHierarchyNode libraryHierarchyNode, int width, int height)
{
var id = this.GetImageId(libraryHierarchyNode, width, height);
var fileName = default(string);
if (FileMetaDataStore.Exists(PREFIX, id, out fileName))
{
return(this.ImageLoader.Load(id, fileName, 0, 0, true));
}
//TODO: Setting throwOnTimeout = false so we ignore synchronization timeout.
//TODO: I think there exists a deadlock bug in KeyLock but I haven't been able to prove it.
using (KeyLock.Lock(id, TIMEOUT, false))
{
if (FileMetaDataStore.Exists(PREFIX, id, out fileName))
{
return(this.ImageLoader.Load(id, fileName, 0, 0, true));
}
return(this.CreateImageSourceCore(libraryHierarchyNode, width, height));
}
}
private ImageSource CreateImageSourceCore(LibraryHierarchyNode libraryHierarchyNode, int width, int height)
{
switch (libraryHierarchyNode.MetaDatas.Length)
{
case 0:
return(this.CreateImageSource0(libraryHierarchyNode, width, height));
case 1:
return(this.CreateImageSource1(libraryHierarchyNode, width, height));
case 2:
return(this.CreateImageSource2(libraryHierarchyNode, width, height));
case 3:
return(this.CreateImageSource3(libraryHierarchyNode, width, height));
default:
return(this.CreateImageSource4(libraryHierarchyNode, width, height));
}
}
protected virtual ImageBrush Create(LibraryHierarchyNode libraryHierarchyNode, bool cache)
{
var source = this.LibraryBrowserTileProvider.CreateImageSource(
libraryHierarchyNode,
this.PixelWidth,
this.PixelWidth,
cache
);
if (source == null)
{
return(this.FallbackValue.Value);
}
var brush = new ImageBrush(source)
{
Stretch = Stretch.Uniform
};
brush.Freeze();
return(brush);
}
private IEnumerable <MetaDataItem> GetMetaDatasCore(LibraryHierarchyNode libraryHierarchyNode, MetaDataItemType?metaDataItemType, string metaDataItemName)
{
using (var database = this.DatabaseFactory.Create())
{
using (var transaction = database.BeginTransaction(database.PreferredIsolationLevel))
{
using (var reader = this.GetReader(database, libraryHierarchyNode, metaDataItemType, metaDataItemName, transaction))
{
foreach (var record in reader)
{
yield return(new MetaDataItem()
{
Name = metaDataItemName,
Type = metaDataItemType.GetValueOrDefault(),
Value = record.Get <string>("Value")
});
}
}
}
}
}
