private void ExtractFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects, Guid?albumMediaItemId, IDictionary <Guid, string> artistMediaItems)
{
if (aspects.ContainsKey(AudioAspect.ASPECT_ID))
{
if (BaseInfo.IsVirtualResource(aspects))
{
return;
}
TrackInfo trackInfo = new TrackInfo();
trackInfo.FromMetadata(aspects);
bool forceFanart = !trackInfo.IsRefreshed;
AlbumInfo albumInfo = trackInfo.CloneBasicInstance <AlbumInfo>();
ExtractLocalImages(aspects, albumMediaItemId, artistMediaItems, albumInfo.ToString());
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadAudioFanArt(mediaItemId, trackInfo, forceFanart);
}
if (albumMediaItemId.HasValue && !_checkCache.Contains(albumMediaItemId.Value))
{
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadAudioFanArt(albumMediaItemId.Value, albumInfo, forceFanart);
}
_checkCache.Add(albumMediaItemId.Value);
}
}
else if (aspects.ContainsKey(PersonAspect.ASPECT_ID))
{
PersonInfo personInfo = new PersonInfo();
personInfo.FromMetadata(aspects);
if (personInfo.Occupation == PersonAspect.OCCUPATION_ARTIST || personInfo.Occupation == PersonAspect.OCCUPATION_COMPOSER)
{
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadAudioFanArt(mediaItemId, personInfo, !personInfo.IsRefreshed);
}
}
}
else if (aspects.ContainsKey(CompanyAspect.ASPECT_ID))
{
CompanyInfo companyInfo = new CompanyInfo();
companyInfo.FromMetadata(aspects);
if (companyInfo.Type == CompanyAspect.COMPANY_MUSIC_LABEL)
{
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
OnlineMatcherService.Instance.DownloadAudioFanArt(mediaItemId, companyInfo, !companyInfo.IsRefreshed);
}
}
}
}
protected async Task ExtractAlbumAndArtistFanArt(Guid mediaItemId, IDictionary <Guid, IList <MediaItemAspect> > aspects)
{
bool shouldCacheLocal = false;
IResourceLocator mediaItemLocator = null;
if (!BaseInfo.IsVirtualResource(aspects))
{
mediaItemLocator = GetResourceLocator(aspects);
//Whether local fanart should be stored in the fanart cache
shouldCacheLocal = ShouldCacheLocalFanArt(mediaItemLocator.NativeResourcePath,
AudioMetadataExtractor.CacheLocalFanArt, AudioMetadataExtractor.CacheOfflineFanArt);
}
if (mediaItemLocator == null)
{
return;
}
if (!shouldCacheLocal && AudioMetadataExtractor.SkipFanArtDownload)
{
return; //Nothing to do
}
TrackInfo trackInfo = new TrackInfo();
trackInfo.FromMetadata(aspects);
AlbumInfo albumInfo = trackInfo.CloneBasicInstance <AlbumInfo>();
string albumTitle = albumInfo.ToString();
ResourcePath albumDirectory = null;
if (shouldCacheLocal)
{
albumDirectory = ResourcePathHelper.Combine(mediaItemLocator.NativeResourcePath, "../");
if (AudioMetadataExtractor.IsDiscFolder(albumTitle, albumDirectory.FileName))
{
//Probably a CD folder so try next parent
albumDirectory = ResourcePathHelper.Combine(albumDirectory, "../");
}
}
//Artist fanart may be stored in the album directory, so get the artists now
IList <Tuple <Guid, string> > artists = GetArtists(aspects);
//Album fanart
if (RelationshipExtractorUtils.TryGetLinkedId(AudioAlbumAspect.ROLE_ALBUM, aspects, out Guid albumMediaItemId) &&
AddToCache(albumMediaItemId))
{
if (shouldCacheLocal)
{
//If the track is not a stub, Store track tag images in the album
if (!aspects.ContainsKey(ReimportAspect.ASPECT_ID) && MediaItemAspect.TryGetAttribute(aspects, MediaAspect.ATTR_ISSTUB, out bool isStub) && isStub == false)
{
await ExtractTagFanArt(mediaItemLocator, albumMediaItemId, albumTitle);
}
await ExtractAlbumFolderFanArt(mediaItemLocator.NativeSystemId, albumDirectory, albumMediaItemId, albumTitle, artists).ConfigureAwait(false);
}
if (!AudioMetadataExtractor.SkipFanArtDownload)
{
await OnlineMatcherService.Instance.DownloadAudioFanArtAsync(albumMediaItemId, albumInfo).ConfigureAwait(false);
}
}
if (shouldCacheLocal && artists != null)
{
await ExtractArtistFolderFanArt(mediaItemLocator.NativeSystemId, albumDirectory, artists).ConfigureAwait(false);
}
}
public override async Task <bool> UpdateFromOnlineMusicTrackAlbumAsync(AlbumInfo album, string language, bool cacheOnly)
{
try
{
bool cacheIncomplete = false;
AudioDbAlbum albumDetail = null;
language = language ?? PreferredLanguage;
if (album.AudioDbId > 0)
{
albumDetail = await _audioDbHandler.GetAlbumAsync(album.AudioDbId, language, cacheOnly).ConfigureAwait(false);
}
if (albumDetail == null && !string.IsNullOrEmpty(album.MusicBrainzGroupId))
{
List <AudioDbAlbum> foundAlbums = await _audioDbHandler.GetAlbumByMbidAsync(album.MusicBrainzGroupId, language, cacheOnly).ConfigureAwait(false);
if (foundAlbums != null && foundAlbums.Count == 1)
{
albumDetail = await _audioDbHandler.GetAlbumAsync(foundAlbums[0].AlbumId, language, cacheOnly).ConfigureAwait(false);
}
}
if (albumDetail == null)
{
return(false);
}
bool languageSet = albumDetail.SetLanguage(language);
album.AudioDbId = albumDetail.AlbumId;
album.MusicBrainzGroupId = albumDetail.MusicBrainzID;
album.AmazonId = albumDetail.AmazonID;
album.ItunesId = albumDetail.ItunesID;
album.Album = albumDetail.Album;
album.Description = new SimpleTitle(albumDetail.Description, !languageSet);
if (!string.IsNullOrEmpty(albumDetail.Genre?.Trim()))
{
album.Genres.Add(new GenreInfo {
Name = albumDetail.Genre.Trim()
});
}
album.Sales = albumDetail.Sales ?? 0;
album.ReleaseDate = albumDetail.Year.HasValue && albumDetail.Year.Value > 1900 ? new DateTime(albumDetail.Year.Value, 1, 1) : default(DateTime?);
album.Rating = new SimpleRating(albumDetail.Rating, albumDetail.RatingCount);
if (albumDetail.ArtistId.HasValue)
{
album.Artists = ConvertToPersons(albumDetail.ArtistId.Value, albumDetail.MusicBrainzArtistID, albumDetail.Artist, PersonAspect.OCCUPATION_ARTIST, null, albumDetail.Album);
}
if (albumDetail.LabelId.HasValue)
{
album.MusicLabels = ConvertToCompanies(albumDetail.LabelId.Value, albumDetail.Label, CompanyAspect.COMPANY_MUSIC_LABEL);
}
List <AudioDbTrack> albumTracks = await _audioDbHandler.GetTracksByAlbumIdAsync(albumDetail.AlbumId, language, cacheOnly).ConfigureAwait(false);
if (cacheOnly && albumTracks == null)
{
cacheIncomplete = true;
}
if (albumTracks != null && albumTracks.Count > 0)
{
album.TotalTracks = albumTracks.Count;
foreach (AudioDbTrack trackDetail in albumTracks)
{
TrackInfo track = new TrackInfo();
track.AudioDbId = trackDetail.TrackID;
track.LyricId = trackDetail.LyricID.HasValue ? trackDetail.LyricID.Value : 0;
track.MvDbId = trackDetail.MvDbID.HasValue ? trackDetail.MvDbID.Value : 0;
track.MusicBrainzId = trackDetail.MusicBrainzID;
track.AlbumAudioDbId = trackDetail.AlbumID.HasValue ? trackDetail.AlbumID.Value : 0;
track.AlbumMusicBrainzGroupId = trackDetail.MusicBrainzAlbumID;
track.AlbumAmazonId = albumDetail.AmazonID;
track.AlbumItunesId = albumDetail.ItunesID;
track.TrackName = trackDetail.Track;
track.Album = albumDetail.Album;
track.TrackNum = trackDetail.TrackNumber;
track.DiscNum = trackDetail.CD.HasValue ? trackDetail.CD.Value : 1;
track.Rating = new SimpleRating(trackDetail.Rating, trackDetail.RatingCount);
track.TrackLyrics = trackDetail.TrackLyrics;
track.Duration = trackDetail.Duration.HasValue ? trackDetail.Duration.Value / 1000 : 0;
if (trackDetail.ArtistID.HasValue)
{
track.Artists = ConvertToPersons(trackDetail.ArtistID.Value, trackDetail.MusicBrainzArtistID, trackDetail.Artist, PersonAspect.OCCUPATION_ARTIST, trackDetail.Track, albumDetail.Album);
}
if (!string.IsNullOrEmpty(trackDetail.Genre?.Trim()))
{
track.Genres.Add(new GenreInfo {
Name = trackDetail.Genre.Trim()
});
}
track.AlbumArtists = album.Artists.ToList();
track.MusicLabels = album.MusicLabels.ToList();
album.Tracks.Add(track);
}
}
return(!cacheIncomplete);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("TheAudioDbWrapper: Exception while processing album {0}", ex, album.ToString());
return(false);
}
}
public override async Task <bool> UpdateFromOnlineMusicTrackAlbumAsync(AlbumInfo album, string language, bool cacheOnly)
{
try
{
TrackRelease albumDetail = null;
if (!string.IsNullOrEmpty(album.MusicBrainzId))
{
albumDetail = await _musicBrainzHandler.GetAlbumAsync(album.MusicBrainzId, cacheOnly).ConfigureAwait(false);
}
if (albumDetail == null)
{
return(false);
}
album.MusicBrainzId = albumDetail.Id;
album.AmazonId = albumDetail.AmazonId;
album.MusicBrainzGroupId = albumDetail.ReleaseGroup != null ? albumDetail.ReleaseGroup.Id : null;
album.Album = albumDetail.Title;
album.TotalTracks = albumDetail.TrackCount;
album.ReleaseDate = albumDetail.Date;
album.Artists = ConvertToPersons(albumDetail.Artists, PersonAspect.OCCUPATION_ARTIST);
if (albumDetail.Labels != null)
{
album.MusicLabels = ConvertToCompanies(albumDetail.Labels, CompanyAspect.COMPANY_MUSIC_LABEL);
}
foreach (TrackMedia media in albumDetail.Media)
{
if (media.Tracks == null || media.Tracks.Count <= 0)
{
continue;
}
if (media.Tracks.Count == album.TotalTracks || album.TotalTracks == 0)
{
foreach (TrackData trackDetail in media.Tracks)
{
TrackInfo track = new TrackInfo();
track.MusicBrainzId = trackDetail.Id;
track.AlbumMusicBrainzId = albumDetail.Id;
track.TrackName = trackDetail.Title;
track.Album = albumDetail.Title;
track.TotalTracks = album.TotalTracks;
track.DiscNum = album.DiscNum;
track.ReleaseDate = album.ReleaseDate;
int trackNo = 0;
if (int.TryParse(trackDetail.Number, out trackNo))
{
track.TrackNum = trackNo;
}
track.Artists = ConvertToPersons(trackDetail.Artists, PersonAspect.OCCUPATION_ARTIST);
track.AlbumArtists = ConvertToPersons(albumDetail.Artists, PersonAspect.OCCUPATION_ARTIST);
album.Tracks.Add(track);
}
}
return(true);
}
return(true);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("MusicBrainzWrapper: Exception while processing album {0}", ex, album.ToString());
return(false);
}
}
public override Task <bool> UpdateFromOnlineMusicTrackAlbumAsync(AlbumInfo album, string language, bool cacheOnly)
{
try
{
if (string.IsNullOrEmpty(album.CdDdId))
{
return(Task.FromResult(false));
}
//TODO: Split CDDB ID into disc id and genre?
string discId = null;
FreeDBCDInfoDetail discInfo;
if (GetCachedDisc(discId, out discInfo))
{
album.Album = discInfo.Title;
album.Artists = ConvertToPersons(discInfo.Artist, PersonAspect.OCCUPATION_ARTIST);
album.TotalTracks = discInfo.Tracks.Count();
album.ReleaseDate = discInfo.Year > 0 ? new DateTime(discInfo.Year, 1, 1) : default(DateTime?);
if (!album.DataProviders.Contains(_name))
{
album.DataProviders.Add(_name);
}
foreach (FreeDBCDTrackDetail trackDetail in discInfo.Tracks)
{
TrackInfo track = new TrackInfo()
{
AlbumCdDdId = album.CdDdId,
Album = discInfo.Title,
AlbumArtists = ConvertToPersons(discInfo.Artist, PersonAspect.OCCUPATION_ARTIST),
TotalTracks = discInfo.Tracks.Count(),
ReleaseDate = discInfo.Year > 0 ? new DateTime(discInfo.Year, 1, 1) : default(DateTime?),
TrackNum = trackDetail.TrackNumber,
TrackName = trackDetail.Title,
Artists = ConvertToPersons(trackDetail.Artist, PersonAspect.OCCUPATION_ARTIST),
Duration = trackDetail.Duration
};
if (!track.DataProviders.Contains(_name))
{
track.DataProviders.Add(_name);
}
album.Tracks.Add(track);
}
return(Task.FromResult(true));
}
return(Task.FromResult(false));
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("FreeDbWrapper: Exception while processing album {0}", ex, album.ToString());
return(Task.FromResult(false));
}
}
