Initial FanArtArtistProvider

MediaBrowser.Controller/MediaBrowser.Controller.csproj

@@ -110,6 +110,7 @@
     <Compile Include="IServerApplicationPaths.cs" />
     <Compile Include="Library\ChildrenChangedEventArgs.cs" />
     <Compile Include="Library\DtoBuilder.cs" />
+    <Compile Include="Providers\Music\FanArtArtistProvider.cs" />
     <Compile Include="Providers\Music\LastfmArtistProvider.cs" />
     <Compile Include="Providers\Music\LastfmBaseArtistProvider.cs" />
     <Compile Include="Resolvers\BaseItemResolver.cs" />

MediaBrowser.Controller/Providers/FanartBaseProvider.cs

@@ -1,4 +1,5 @@
-using MediaBrowser.Controller.Entities;
+using System.Collections.Generic;
+using MediaBrowser.Controller.Entities;
 using System;
 using MediaBrowser.Model.Logging;
 
@@ -13,29 +14,44 @@ namespace MediaBrowser.Controller.Providers
         /// The LOG o_ FILE
         /// </summary>
         protected const string LOGO_FILE = "logo.png";
+
         /// <summary>
         /// The AR t_ FILE
         /// </summary>
         protected const string ART_FILE = "clearart.png";
+
         /// <summary>
         /// The THUM b_ FILE
         /// </summary>
         protected const string THUMB_FILE = "thumb.jpg";
+
         /// <summary>
         /// The DIS c_ FILE
         /// </summary>
         protected const string DISC_FILE = "disc.png";
+
         /// <summary>
         /// The BANNE r_ FILE
         /// </summary>
         protected const string BANNER_FILE = "banner.png";
 
+        /// <summary>
+        /// The Backdrop
+        /// </summary>
+        protected const string BACKDROP_FILE = "backdrop.jpg";
+
+        /// <summary>
+        /// The Primary image
+        /// </summary>
+        protected const string PRIMARY_FILE = "folder.jpg";
+
         /// <summary>
         /// The API key
         /// </summary>
         protected const string APIKey = "5c6b04c68e904cfed1e6cbc9a9e683d4";
 
-        protected FanartBaseProvider(ILogManager logManager) : base(logManager)
+        protected FanartBaseProvider(ILogManager logManager)
+            : base(logManager)
         {
         }
 
@@ -49,8 +65,8 @@ namespace MediaBrowser.Controller.Providers
         {
             if (item.DontFetchMeta) return false;
 
-            return DateTime.UtcNow > (providerInfo.LastRefreshed.AddDays(Kernel.Instance.Configuration.MetadataRefreshDays)) 
-                && ShouldFetch(item, providerInfo);
+            return DateTime.UtcNow > (providerInfo.LastRefreshed.AddDays(Kernel.Instance.Configuration.MetadataRefreshDays))
+                   && ShouldFetch(item, providerInfo);
         }
 
         /// <summary>
@@ -59,10 +75,7 @@ namespace MediaBrowser.Controller.Providers
         /// <value><c>true</c> if [requires internet]; otherwise, <c>false</c>.</value>
         public override bool RequiresInternet
         {
-            get
-            {
-                return true;
-            }
+            get { return true; }
         }
 
         /// <summary>
@@ -84,6 +97,32 @@ namespace MediaBrowser.Controller.Providers
         {
             return false;
         }
+        #region Result Objects
+
+        protected class FanArtImageInfo
+        {
+            public string id { get; set; }
+            public string url { get; set; }
+            public string likes { get; set; }
+        }
+
+        protected class FanArtMusicInfo
+        {
+            public string mbid_id { get; set; }
+            public List<FanArtImageInfo> musiclogo { get; set; }
+            public List<FanArtImageInfo> artistbackground { get; set; }
+            public List<FanArtImageInfo> artistthumb { get; set; }
+            public List<FanArtImageInfo> hdmusiclogo { get; set; }
+            public List<FanArtImageInfo> musicbanner { get; set; }
+        }
+
+        protected class FanArtMusicResult
+        {
+            public FanArtMusicInfo result { get; set; }
+        }
+
+        #endregion
 
     }
+
 }

MediaBrowser.Controller/Providers/Music/FanArtArtistProvider.cs

@@ -0,0 +1,240 @@
+using System.Collections.Specialized;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Net;
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace MediaBrowser.Controller.Providers.Music
+{
+    /// <summary>
+    /// Class FanArtArtistProvider
+    /// </summary>
+    class FanArtArtistProvider : FanartBaseProvider
+    {
+        /// <summary>
+        /// Gets the HTTP client.
+        /// </summary>
+        /// <value>The HTTP client.</value>
+        protected IHttpClient HttpClient { get; private set; }
+
+        public FanArtArtistProvider(IHttpClient httpClient, ILogManager logManager)
+            : base(logManager)
+        {
+            if (httpClient == null)
+            {
+                throw new ArgumentNullException("httpClient");
+            }
+            HttpClient = httpClient;
+        }
+
+        /// <summary>
+        /// The fan art base URL
+        /// </summary>
+        protected string FanArtBaseUrl = "http://api.fanart.tv/webservice/artist/{0}/{1}/xml/all/1/1";
+
+        /// <summary>
+        /// Supportses the specified item.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
+        public override bool Supports(BaseItem item)
+        {
+            return item is MusicArtist;
+        }
+
+        /// <summary>
+        /// Shoulds the fetch.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="providerInfo">The provider info.</param>
+        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
+        protected override bool ShouldFetch(BaseItem item, BaseProviderInfo providerInfo)
+        {
+            var baseItem = item;
+            if (item.Path == null || item.DontFetchMeta || string.IsNullOrEmpty(baseItem.GetProviderId(MetadataProviders.Musicbrainz))) return false; //nothing to do
+            var artExists = item.ResolveArgs.ContainsMetaFileByName(ART_FILE);
+            var logoExists = item.ResolveArgs.ContainsMetaFileByName(LOGO_FILE);
+            var discExists = item.ResolveArgs.ContainsMetaFileByName(DISC_FILE);
+
+            return (!artExists && Kernel.Instance.Configuration.DownloadMovieArt)
+                || (!logoExists && Kernel.Instance.Configuration.DownloadMovieLogo)
+                || (!discExists && Kernel.Instance.Configuration.DownloadMovieDisc);
+        }
+
+        /// <summary>
+        /// Fetches metadata and returns true or false indicating if any work that requires persistence was done
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="force">if set to <c>true</c> [force].</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{System.Boolean}.</returns>
+        protected override async Task<bool> FetchAsyncInternal(BaseItem item, bool force, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var artist = item;
+            if (ShouldFetch(artist, artist.ProviderData.GetValueOrDefault(Id, new BaseProviderInfo { ProviderId = Id })))
+            {
+                var url = string.Format(FanArtBaseUrl, APIKey, artist.GetProviderId(MetadataProviders.Musicbrainz));
+                var doc = new XmlDocument();
+
+                try
+                {
+                    using (var xml = await HttpClient.Get(url, Kernel.Instance.ResourcePools.FanArt, cancellationToken).ConfigureAwait(false))
+                    {
+                        doc.Load(xml);
+                    }
+                }
+                catch (HttpException)
+                {
+                }
+
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (doc.HasChildNodes)
+                {
+                    string path;
+                    var hd = Kernel.Instance.Configuration.DownloadHDFanArt ? "hd" : "";
+                    if (Kernel.Instance.Configuration.DownloadMovieLogo && !item.ResolveArgs.ContainsMetaFileByName(LOGO_FILE))
+                    {
+                        var node =
+                            doc.SelectSingleNode("//fanart/music/musiclogos/" + hd + "musiclogo/@url") ??
+                            doc.SelectSingleNode("//fanart/music/musiclogos/musiclogo/@url");
+                        path = node != null ? node.Value : null;
+                        if (!string.IsNullOrEmpty(path))
+                        {
+                            Logger.Debug("FanArtProvider getting ClearLogo for " + artist.Name);
+                            try
+                            {
+                                artist.SetImage(ImageType.Logo, await Kernel.Instance.ProviderManager.DownloadAndSaveImage(artist, path, LOGO_FILE, Kernel.Instance.ResourcePools.FanArt, cancellationToken).ConfigureAwait(false));
+                            }
+                            catch (HttpException)
+                            {
+                            }
+                            catch (IOException)
+                            {
+
+                            }
+                        }
+                    }
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    if (!item.ResolveArgs.ContainsMetaFileByName(BACKDROP_FILE))
+                    {
+                        var nodes = doc.SelectNodes("//fanart/music/artistbackgrounds//@url");
+                        if (nodes != null)
+                        {
+                            var numBackdrops = 0;
+                            foreach (XmlNode node in nodes)
+                            {
+                                path = node.Value;
+                                if (!string.IsNullOrEmpty(path))
+                                {
+                                    Logger.Debug("FanArtProvider getting Backdrop for " + artist.Name);
+                                    try
+                                    {
+                                        artist.BackdropImagePaths.Add(await Kernel.Instance.ProviderManager.DownloadAndSaveImage(artist, path, ("Backdrop"+(numBackdrops > 0 ? numBackdrops.ToString() : "")+".jpg"), Kernel.Instance.ResourcePools.FanArt, cancellationToken).ConfigureAwait(false));
+                                        numBackdrops++;
+                                        if (numBackdrops >= Kernel.Instance.Configuration.MaxBackdrops) break;
+                                    }
+                                    catch (HttpException)
+                                    {
+                                    }
+                                    catch (IOException)
+                                    {
+
+                                    }
+                                }
+                            }
+                            
+                        }
+
+                    }
+
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    if (Kernel.Instance.Configuration.DownloadMovieArt && !item.ResolveArgs.ContainsMetaFileByName(ART_FILE))
+                    {
+                        var node =
+                            doc.SelectSingleNode("//fanart/music/musicarts/" + hd + "musicart/@url") ??
+                            doc.SelectSingleNode("//fanart/music/musicarts/musicart/@url");
+                        path = node != null ? node.Value : null;
+                        if (!string.IsNullOrEmpty(path))
+                        {
+                            Logger.Debug("FanArtProvider getting ClearArt for " + artist.Name);
+                            try
+                            {
+                                artist.SetImage(ImageType.Art, await Kernel.Instance.ProviderManager.DownloadAndSaveImage(artist, path, ART_FILE, Kernel.Instance.ResourcePools.FanArt, cancellationToken).ConfigureAwait(false));
+                            }
+                            catch (HttpException)
+                            {
+                            }
+                            catch (IOException)
+                            {
+
+                            }
+                        }
+                    }
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    if (Kernel.Instance.Configuration.DownloadMovieBanner && !item.ResolveArgs.ContainsMetaFileByName(BANNER_FILE))
+                    {
+                        var node = doc.SelectSingleNode("//fanart/music/musicbanners/"+hd+"musicbanner/@url") ??
+                                   doc.SelectSingleNode("//fanart/music/musicbanners/musicbanner/@url");
+                        path = node != null ? node.Value : null;
+                        if (!string.IsNullOrEmpty(path))
+                        {
+                            Logger.Debug("FanArtProvider getting Banner for " + artist.Name);
+                            try
+                            {
+                                artist.SetImage(ImageType.Banner, await Kernel.Instance.ProviderManager.DownloadAndSaveImage(artist, path, BANNER_FILE, Kernel.Instance.ResourcePools.FanArt, cancellationToken).ConfigureAwait(false));
+                            }
+                            catch (HttpException)
+                            {
+                            }
+                            catch (IOException)
+                            {
+
+                            }
+                        }
+                    }
+
+                    cancellationToken.ThrowIfCancellationRequested();
+
+                    // Artist thumbs are actually primary images (they are square/portrait)
+                    if (!item.ResolveArgs.ContainsMetaFileByName(PRIMARY_FILE))
+                    {
+                        var node = doc.SelectSingleNode("//fanart/music/artistthumbs/artistthumb/@url");
+                        path = node != null ? node.Value : null;
+                        if (!string.IsNullOrEmpty(path))
+                        {
+                            Logger.Debug("FanArtProvider getting Primary image for " + artist.Name);
+                            try
+                            {
+                                artist.SetImage(ImageType.Primary, await Kernel.Instance.ProviderManager.DownloadAndSaveImage(artist, path, PRIMARY_FILE, Kernel.Instance.ResourcePools.FanArt, cancellationToken).ConfigureAwait(false));
+                            }
+                            catch (HttpException)
+                            {
+                            }
+                            catch (IOException)
+                            {
+
+                            }
+                        }
+                    }
+                }
+            }
+            SetLastRefreshed(artist, DateTime.UtcNow);
+            return true;
+        }
+    }
+}

MediaBrowser.Controller/Providers/Music/LastfmArtistProvider.cs

@@ -6,6 +6,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using MediaBrowser.Common.Net;
+using MediaBrowser.Model.Entities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Model.Logging;

MediaBrowser.Controller/Providers/Music/LastfmBaseProvider.cs

@@ -195,6 +195,8 @@ namespace MediaBrowser.Controller.Providers.Music
 
                 cancellationToken.ThrowIfCancellationRequested();
 
+                item.SetProviderId(MetadataProviders.Musicbrainz, id);
+
                 await FetchLastfmData(item, id, cancellationToken).ConfigureAwait(false);
             }
             else