Merge pull request #2536 from dkanada/audiodbv10.5.0

Migrate AudioDB to use plugin interface

8 files changed, 944 insertions, 0 deletions

diff --git a/MediaBrowser.Providers/Plugins/AudioDb/AlbumImageProvider.cs b/MediaBrowser.Providers/Plugins/AudioDb/AlbumImageProvider.cs
new file mode 100644
index 000000000..dee2d59f0
--- /dev/null
+++ b/MediaBrowser.Providers/Plugins/AudioDb/AlbumImageProvider.cs
@@ -0,0 +1,108 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.Model.Serialization;
+
+namespace MediaBrowser.Providers.Plugins.AudioDb
+{
+    public class AudioDbAlbumImageProvider : IRemoteImageProvider, IHasOrder
+    {
+        private readonly IServerConfigurationManager _config;
+        private readonly IHttpClient _httpClient;
+        private readonly IJsonSerializer _json;
+
+        public AudioDbAlbumImageProvider(IServerConfigurationManager config, IHttpClient httpClient, IJsonSerializer json)
+        {
+            _config = config;
+            _httpClient = httpClient;
+            _json = json;
+        }
+
+        /// <inheritdoc />
+        public string Name => "TheAudioDB";
+
+        /// <inheritdoc />
+        // After embedded and fanart
+        public int Order => 2;
+
+        /// <inheritdoc />
+        public IEnumerable<ImageType> GetSupportedImages(BaseItem item)
+        {
+            return new List<ImageType>
+            {
+                ImageType.Primary,
+                ImageType.Disc
+            };
+        }
+
+        /// <inheritdoc />
+        public async Task<IEnumerable<RemoteImageInfo>> GetImages(BaseItem item, CancellationToken cancellationToken)
+        {
+            var id = item.GetProviderId(MetadataProviders.MusicBrainzReleaseGroup);
+
+            if (!string.IsNullOrWhiteSpace(id))
+            {
+                await AudioDbAlbumProvider.Current.EnsureInfo(id, cancellationToken).ConfigureAwait(false);
+
+                var path = AudioDbAlbumProvider.GetAlbumInfoPath(_config.ApplicationPaths, id);
+
+                var obj = _json.DeserializeFromFile<AudioDbAlbumProvider.RootObject>(path);
+
+                if (obj != null && obj.album != null && obj.album.Count > 0)
+                {
+                    return GetImages(obj.album[0]);
+                }
+            }
+
+            return new List<RemoteImageInfo>();
+        }
+
+        private IEnumerable<RemoteImageInfo> GetImages(AudioDbAlbumProvider.Album item)
+        {
+            var list = new List<RemoteImageInfo>();
+
+            if (!string.IsNullOrWhiteSpace(item.strAlbumThumb))
+            {
+                list.Add(new RemoteImageInfo
+                {
+                    ProviderName = Name,
+                    Url = item.strAlbumThumb,
+                    Type = ImageType.Primary
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(item.strAlbumCDart))
+            {
+                list.Add(new RemoteImageInfo
+                {
+                    ProviderName = Name,
+                    Url = item.strAlbumCDart,
+                    Type = ImageType.Disc
+                });
+            }
+
+            return list;
+        }
+
+        /// <inheritdoc />
+        public Task<HttpResponseInfo> GetImageResponse(string url, CancellationToken cancellationToken)
+        {
+            return _httpClient.GetResponse(new HttpRequestOptions
+            {
+                CancellationToken = cancellationToken,
+                Url = url
+            });
+        }
+
+        /// <inheritdoc />
+        public bool Supports(BaseItem item)
+            => Plugin.Instance.Configuration.Enable && item is MusicAlbum;
+    }
+}
diff --git a/MediaBrowser.Providers/Plugins/AudioDb/AlbumProvider.cs b/MediaBrowser.Providers/Plugins/AudioDb/AlbumProvider.cs
new file mode 100644
index 000000000..1a0e87871
--- /dev/null
+++ b/MediaBrowser.Providers/Plugins/AudioDb/AlbumProvider.cs
@@ -0,0 +1,263 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.Model.Serialization;
+using MediaBrowser.Providers.Music;
+
+namespace MediaBrowser.Providers.Plugins.AudioDb
+{
+    public class AudioDbAlbumProvider : IRemoteMetadataProvider<MusicAlbum, AlbumInfo>, IHasOrder
+    {
+        private readonly IServerConfigurationManager _config;
+        private readonly IFileSystem _fileSystem;
+        private readonly IHttpClient _httpClient;
+        private readonly IJsonSerializer _json;
+
+        public static AudioDbAlbumProvider Current;
+
+        public AudioDbAlbumProvider(IServerConfigurationManager config, IFileSystem fileSystem, IHttpClient httpClient, IJsonSerializer json)
+        {
+            _config = config;
+            _fileSystem = fileSystem;
+            _httpClient = httpClient;
+            _json = json;
+
+            Current = this;
+        }
+
+        /// <inheritdoc />
+        public string Name => "TheAudioDB";
+
+        /// <inheritdoc />
+        // After music brainz
+        public int Order => 1;
+
+        /// <inheritdoc />
+        public Task<IEnumerable<RemoteSearchResult>> GetSearchResults(AlbumInfo searchInfo, CancellationToken cancellationToken)
+            => Task.FromResult(Enumerable.Empty<RemoteSearchResult>());
+
+        /// <inheritdoc />
+        public async Task<MetadataResult<MusicAlbum>> GetMetadata(AlbumInfo info, CancellationToken cancellationToken)
+        {
+            var result = new MetadataResult<MusicAlbum>();
+
+            // TODO maybe remove when artist metadata can be disabled
+            if (!Plugin.Instance.Configuration.Enable)
+            {
+                return result;
+            }
+
+            var id = info.GetReleaseGroupId();
+
+            if (!string.IsNullOrWhiteSpace(id))
+            {
+                await EnsureInfo(id, cancellationToken).ConfigureAwait(false);
+
+                var path = GetAlbumInfoPath(_config.ApplicationPaths, id);
+
+                var obj = _json.DeserializeFromFile<RootObject>(path);
+
+                if (obj != null && obj.album != null && obj.album.Count > 0)
+                {
+                    result.Item = new MusicAlbum();
+                    result.HasMetadata = true;
+                    ProcessResult(result.Item, obj.album[0], info.MetadataLanguage);
+                }
+            }
+
+            return result;
+        }
+
+        private void ProcessResult(MusicAlbum item, Album result, string preferredLanguage)
+        {
+            if (Plugin.Instance.Configuration.ReplaceAlbumName && !string.IsNullOrWhiteSpace(result.strAlbum))
+            {
+                item.Album = result.strAlbum;
+            }
+
+            if (!string.IsNullOrWhiteSpace(result.strArtist))
+            {
+                item.AlbumArtists = new string[] { result.strArtist };
+            }
+
+            if (!string.IsNullOrEmpty(result.intYearReleased))
+            {
+                item.ProductionYear = int.Parse(result.intYearReleased, CultureInfo.InvariantCulture);
+            }
+
+            if (!string.IsNullOrEmpty(result.strGenre))
+            {
+                item.Genres = new[] { result.strGenre };
+            }
+
+            item.SetProviderId(MetadataProviders.AudioDbArtist, result.idArtist);
+            item.SetProviderId(MetadataProviders.AudioDbAlbum, result.idAlbum);
+
+            item.SetProviderId(MetadataProviders.MusicBrainzAlbumArtist, result.strMusicBrainzArtistID);
+            item.SetProviderId(MetadataProviders.MusicBrainzReleaseGroup, result.strMusicBrainzID);
+
+            string overview = null;
+
+            if (string.Equals(preferredLanguage, "de", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strDescriptionDE;
+            }
+            else if (string.Equals(preferredLanguage, "fr", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strDescriptionFR;
+            }
+            else if (string.Equals(preferredLanguage, "nl", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strDescriptionNL;
+            }
+            else if (string.Equals(preferredLanguage, "ru", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strDescriptionRU;
+            }
+            else if (string.Equals(preferredLanguage, "it", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strDescriptionIT;
+            }
+            else if ((preferredLanguage ?? string.Empty).StartsWith("pt", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strDescriptionPT;
+            }
+
+            if (string.IsNullOrWhiteSpace(overview))
+            {
+                overview = result.strDescriptionEN;
+            }
+
+            item.Overview = (overview ?? string.Empty).StripHtml();
+        }
+
+        internal Task EnsureInfo(string musicBrainzReleaseGroupId, CancellationToken cancellationToken)
+        {
+            var xmlPath = GetAlbumInfoPath(_config.ApplicationPaths, musicBrainzReleaseGroupId);
+
+            var fileInfo = _fileSystem.GetFileSystemInfo(xmlPath);
+
+            if (fileInfo.Exists)
+            {
+                if ((DateTime.UtcNow - _fileSystem.GetLastWriteTimeUtc(fileInfo)).TotalDays <= 2)
+                {
+                    return Task.CompletedTask;
+                }
+            }
+
+            return DownloadInfo(musicBrainzReleaseGroupId, cancellationToken);
+        }
+
+        internal async Task DownloadInfo(string musicBrainzReleaseGroupId, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var url = AudioDbArtistProvider.BaseUrl + "/album-mb.php?i=" + musicBrainzReleaseGroupId;
+
+            var path = GetAlbumInfoPath(_config.ApplicationPaths, musicBrainzReleaseGroupId);
+
+            Directory.CreateDirectory(Path.GetDirectoryName(path));
+
+            using (var httpResponse = await _httpClient.SendAsync(
+                new HttpRequestOptions
+                {
+                    Url = url,
+                    CancellationToken = cancellationToken
+                },
+                HttpMethod.Get).ConfigureAwait(false))
+            using (var response = httpResponse.Content)
+            using (var xmlFileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read, IODefaults.FileStreamBufferSize, true))
+            {
+                await response.CopyToAsync(xmlFileStream).ConfigureAwait(false);
+            }
+        }
+
+        private static string GetAlbumDataPath(IApplicationPaths appPaths, string musicBrainzReleaseGroupId)
+        {
+            var dataPath = Path.Combine(GetAlbumDataPath(appPaths), musicBrainzReleaseGroupId);
+
+            return dataPath;
+        }
+
+        private static string GetAlbumDataPath(IApplicationPaths appPaths)
+        {
+            var dataPath = Path.Combine(appPaths.CachePath, "audiodb-album");
+
+            return dataPath;
+        }
+
+        internal static string GetAlbumInfoPath(IApplicationPaths appPaths, string musicBrainzReleaseGroupId)
+        {
+            var dataPath = GetAlbumDataPath(appPaths, musicBrainzReleaseGroupId);
+
+            return Path.Combine(dataPath, "album.json");
+        }
+
+        public class Album
+        {
+            public string idAlbum { get; set; }
+            public string idArtist { get; set; }
+            public string strAlbum { get; set; }
+            public string strArtist { get; set; }
+            public string intYearReleased { get; set; }
+            public string strGenre { get; set; }
+            public string strSubGenre { get; set; }
+            public string strReleaseFormat { get; set; }
+            public string intSales { get; set; }
+            public string strAlbumThumb { get; set; }
+            public string strAlbumCDart { get; set; }
+            public string strDescriptionEN { get; set; }
+            public string strDescriptionDE { get; set; }
+            public string strDescriptionFR { get; set; }
+            public string strDescriptionCN { get; set; }
+            public string strDescriptionIT { get; set; }
+            public string strDescriptionJP { get; set; }
+            public string strDescriptionRU { get; set; }
+            public string strDescriptionES { get; set; }
+            public string strDescriptionPT { get; set; }
+            public string strDescriptionSE { get; set; }
+            public string strDescriptionNL { get; set; }
+            public string strDescriptionHU { get; set; }
+            public string strDescriptionNO { get; set; }
+            public string strDescriptionIL { get; set; }
+            public string strDescriptionPL { get; set; }
+            public object intLoved { get; set; }
+            public object intScore { get; set; }
+            public string strReview { get; set; }
+            public object strMood { get; set; }
+            public object strTheme { get; set; }
+            public object strSpeed { get; set; }
+            public object strLocation { get; set; }
+            public string strMusicBrainzID { get; set; }
+            public string strMusicBrainzArtistID { get; set; }
+            public object strItunesID { get; set; }
+            public object strAmazonID { get; set; }
+            public string strLocked { get; set; }
+        }
+
+        public class RootObject
+        {
+            public List<Album> album { get; set; }
+        }
+
+        /// <inheritdoc />
+        public Task<HttpResponseInfo> GetImageResponse(string url, CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/MediaBrowser.Providers/Plugins/AudioDb/ArtistImageProvider.cs b/MediaBrowser.Providers/Plugins/AudioDb/ArtistImageProvider.cs
new file mode 100644
index 000000000..18afd5dd5
--- /dev/null
+++ b/MediaBrowser.Providers/Plugins/AudioDb/ArtistImageProvider.cs
@@ -0,0 +1,149 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.Model.Serialization;
+
+namespace MediaBrowser.Providers.Plugins.AudioDb
+{
+    public class AudioDbArtistImageProvider : IRemoteImageProvider, IHasOrder
+    {
+        private readonly IServerConfigurationManager _config;
+        private readonly IHttpClient _httpClient;
+        private readonly IJsonSerializer _json;
+
+        public AudioDbArtistImageProvider(IServerConfigurationManager config, IJsonSerializer json, IHttpClient httpClient)
+        {
+            _config = config;
+            _json = json;
+            _httpClient = httpClient;
+        }
+
+        /// <inheritdoc />
+        public string Name => "TheAudioDB";
+
+        /// <inheritdoc />
+        // After fanart
+        public int Order => 1;
+
+        /// <inheritdoc />
+        public IEnumerable<ImageType> GetSupportedImages(BaseItem item)
+        {
+            return new List<ImageType>
+            {
+                ImageType.Primary,
+                ImageType.Logo,
+                ImageType.Banner,
+                ImageType.Backdrop
+            };
+        }
+
+        /// <inheritdoc />
+        public async Task<IEnumerable<RemoteImageInfo>> GetImages(BaseItem item, CancellationToken cancellationToken)
+        {
+            var id = item.GetProviderId(MetadataProviders.MusicBrainzArtist);
+
+            if (!string.IsNullOrWhiteSpace(id))
+            {
+                await AudioDbArtistProvider.Current.EnsureArtistInfo(id, cancellationToken).ConfigureAwait(false);
+
+                var path = AudioDbArtistProvider.GetArtistInfoPath(_config.ApplicationPaths, id);
+
+                var obj = _json.DeserializeFromFile<AudioDbArtistProvider.RootObject>(path);
+
+                if (obj != null && obj.artists != null && obj.artists.Count > 0)
+                {
+                    return GetImages(obj.artists[0]);
+                }
+            }
+
+            return new List<RemoteImageInfo>();
+        }
+
+        private IEnumerable<RemoteImageInfo> GetImages(AudioDbArtistProvider.Artist item)
+        {
+            var list = new List<RemoteImageInfo>();
+
+            if (!string.IsNullOrWhiteSpace(item.strArtistThumb))
+            {
+                list.Add(new RemoteImageInfo
+                {
+                    ProviderName = Name,
+                    Url = item.strArtistThumb,
+                    Type = ImageType.Primary
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(item.strArtistLogo))
+            {
+                list.Add(new RemoteImageInfo
+                {
+                    ProviderName = Name,
+                    Url = item.strArtistLogo,
+                    Type = ImageType.Logo
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(item.strArtistBanner))
+            {
+                list.Add(new RemoteImageInfo
+                {
+                    ProviderName = Name,
+                    Url = item.strArtistBanner,
+                    Type = ImageType.Banner
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(item.strArtistFanart))
+            {
+                list.Add(new RemoteImageInfo
+                {
+                    ProviderName = Name,
+                    Url = item.strArtistFanart,
+                    Type = ImageType.Backdrop
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(item.strArtistFanart2))
+            {
+                list.Add(new RemoteImageInfo
+                {
+                    ProviderName = Name,
+                    Url = item.strArtistFanart2,
+                    Type = ImageType.Backdrop
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(item.strArtistFanart3))
+            {
+                list.Add(new RemoteImageInfo
+                {
+                    ProviderName = Name,
+                    Url = item.strArtistFanart3,
+                    Type = ImageType.Backdrop
+                });
+            }
+
+            return list;
+        }
+
+        public Task<HttpResponseInfo> GetImageResponse(string url, CancellationToken cancellationToken)
+        {
+            return _httpClient.GetResponse(new HttpRequestOptions
+            {
+                CancellationToken = cancellationToken,
+                Url = url
+            });
+        }
+
+        /// <inheritdoc />
+        public bool Supports(BaseItem item)
+            => Plugin.Instance.Configuration.Enable && item is MusicArtist;
+    }
+}
diff --git a/MediaBrowser.Providers/Plugins/AudioDb/ArtistProvider.cs b/MediaBrowser.Providers/Plugins/AudioDb/ArtistProvider.cs
new file mode 100644
index 000000000..df0f3df8f
--- /dev/null
+++ b/MediaBrowser.Providers/Plugins/AudioDb/ArtistProvider.cs
@@ -0,0 +1,255 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Providers;
+using MediaBrowser.Model.Serialization;
+using MediaBrowser.Providers.Music;
+
+namespace MediaBrowser.Providers.Plugins.AudioDb
+{
+    public class AudioDbArtistProvider : IRemoteMetadataProvider<MusicArtist, ArtistInfo>, IHasOrder
+    {
+        private readonly IServerConfigurationManager _config;
+        private readonly IFileSystem _fileSystem;
+        private readonly IHttpClient _httpClient;
+        private readonly IJsonSerializer _json;
+
+        public static AudioDbArtistProvider Current;
+
+        private const string ApiKey = "195003";
+        public const string BaseUrl = "https://www.theaudiodb.com/api/v1/json/" + ApiKey;
+
+        public AudioDbArtistProvider(IServerConfigurationManager config, IFileSystem fileSystem, IHttpClient httpClient, IJsonSerializer json)
+        {
+            _config = config;
+            _fileSystem = fileSystem;
+            _httpClient = httpClient;
+            _json = json;
+            Current = this;
+        }
+
+        /// <inheritdoc />
+        public string Name => "TheAudioDB";
+
+        /// <inheritdoc />
+        // After musicbrainz
+        public int Order => 1;
+
+        /// <inheritdoc />
+        public Task<IEnumerable<RemoteSearchResult>> GetSearchResults(ArtistInfo searchInfo, CancellationToken cancellationToken)
+            => Task.FromResult(Enumerable.Empty<RemoteSearchResult>());
+
+        /// <inheritdoc />
+        public async Task<MetadataResult<MusicArtist>> GetMetadata(ArtistInfo info, CancellationToken cancellationToken)
+        {
+            var result = new MetadataResult<MusicArtist>();
+
+            // TODO maybe remove when artist metadata can be disabled
+            if (!Plugin.Instance.Configuration.Enable)
+            {
+                return result;
+            }
+
+            var id = info.GetMusicBrainzArtistId();
+
+            if (!string.IsNullOrWhiteSpace(id))
+            {
+                await EnsureArtistInfo(id, cancellationToken).ConfigureAwait(false);
+
+                var path = GetArtistInfoPath(_config.ApplicationPaths, id);
+
+                var obj = _json.DeserializeFromFile<RootObject>(path);
+
+                if (obj != null && obj.artists != null && obj.artists.Count > 0)
+                {
+                    result.Item = new MusicArtist();
+                    result.HasMetadata = true;
+                    ProcessResult(result.Item, obj.artists[0], info.MetadataLanguage);
+                }
+            }
+
+            return result;
+        }
+
+        private void ProcessResult(MusicArtist item, Artist result, string preferredLanguage)
+        {
+            //item.HomePageUrl = result.strWebsite;
+
+            if (!string.IsNullOrEmpty(result.strGenre))
+            {
+                item.Genres = new[] { result.strGenre };
+            }
+
+            item.SetProviderId(MetadataProviders.AudioDbArtist, result.idArtist);
+            item.SetProviderId(MetadataProviders.MusicBrainzArtist, result.strMusicBrainzID);
+
+            string overview = null;
+
+            if (string.Equals(preferredLanguage, "de", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strBiographyDE;
+            }
+            else if (string.Equals(preferredLanguage, "fr", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strBiographyFR;
+            }
+            else if (string.Equals(preferredLanguage, "nl", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strBiographyNL;
+            }
+            else if (string.Equals(preferredLanguage, "ru", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strBiographyRU;
+            }
+            else if (string.Equals(preferredLanguage, "it", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strBiographyIT;
+            }
+            else if ((preferredLanguage ?? string.Empty).StartsWith("pt", StringComparison.OrdinalIgnoreCase))
+            {
+                overview = result.strBiographyPT;
+            }
+
+            if (string.IsNullOrWhiteSpace(overview))
+            {
+                overview = result.strBiographyEN;
+            }
+
+            item.Overview = (overview ?? string.Empty).StripHtml();
+        }
+
+        internal Task EnsureArtistInfo(string musicBrainzId, CancellationToken cancellationToken)
+        {
+            var xmlPath = GetArtistInfoPath(_config.ApplicationPaths, musicBrainzId);
+
+            var fileInfo = _fileSystem.GetFileSystemInfo(xmlPath);
+
+            if (fileInfo.Exists
+                && (DateTime.UtcNow - _fileSystem.GetLastWriteTimeUtc(fileInfo)).TotalDays <= 2)
+            {
+                return Task.CompletedTask;
+            }
+
+            return DownloadArtistInfo(musicBrainzId, cancellationToken);
+        }
+
+        internal async Task DownloadArtistInfo(string musicBrainzId, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var url = BaseUrl + "/artist-mb.php?i=" + musicBrainzId;
+
+            var path = GetArtistInfoPath(_config.ApplicationPaths, musicBrainzId);
+
+            using (var httpResponse = await _httpClient.SendAsync(
+                new HttpRequestOptions
+                {
+                    Url = url,
+                    CancellationToken = cancellationToken,
+                    BufferContent = true
+                },
+                HttpMethod.Get).ConfigureAwait(false))
+            using (var response = httpResponse.Content)
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(path));
+
+                using (var xmlFileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read, IODefaults.FileStreamBufferSize, true))
+                {
+                    await response.CopyToAsync(xmlFileStream).ConfigureAwait(false);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the artist data path.
+        /// </summary>
+        /// <param name="appPaths">The application paths.</param>
+        /// <param name="musicBrainzArtistId">The music brainz artist identifier.</param>
+        /// <returns>System.String.</returns>
+        private static string GetArtistDataPath(IApplicationPaths appPaths, string musicBrainzArtistId)
+            => Path.Combine(GetArtistDataPath(appPaths), musicBrainzArtistId);
+
+        /// <summary>
+        /// Gets the artist data path.
+        /// </summary>
+        /// <param name="appPaths">The application paths.</param>
+        /// <returns>System.String.</returns>
+        private static string GetArtistDataPath(IApplicationPaths appPaths)
+            => Path.Combine(appPaths.CachePath, "audiodb-artist");
+
+        internal static string GetArtistInfoPath(IApplicationPaths appPaths, string musicBrainzArtistId)
+        {
+            var dataPath = GetArtistDataPath(appPaths, musicBrainzArtistId);
+
+            return Path.Combine(dataPath, "artist.json");
+        }
+
+        public class Artist
+        {
+            public string idArtist { get; set; }
+            public string strArtist { get; set; }
+            public string strArtistAlternate { get; set; }
+            public object idLabel { get; set; }
+            public string intFormedYear { get; set; }
+            public string intBornYear { get; set; }
+            public object intDiedYear { get; set; }
+            public object strDisbanded { get; set; }
+            public string strGenre { get; set; }
+            public string strSubGenre { get; set; }
+            public string strWebsite { get; set; }
+            public string strFacebook { get; set; }
+            public string strTwitter { get; set; }
+            public string strBiographyEN { get; set; }
+            public string strBiographyDE { get; set; }
+            public string strBiographyFR { get; set; }
+            public string strBiographyCN { get; set; }
+            public string strBiographyIT { get; set; }
+            public string strBiographyJP { get; set; }
+            public string strBiographyRU { get; set; }
+            public string strBiographyES { get; set; }
+            public string strBiographyPT { get; set; }
+            public string strBiographySE { get; set; }
+            public string strBiographyNL { get; set; }
+            public string strBiographyHU { get; set; }
+            public string strBiographyNO { get; set; }
+            public string strBiographyIL { get; set; }
+            public string strBiographyPL { get; set; }
+            public string strGender { get; set; }
+            public string intMembers { get; set; }
+            public string strCountry { get; set; }
+            public string strCountryCode { get; set; }
+            public string strArtistThumb { get; set; }
+            public string strArtistLogo { get; set; }
+            public string strArtistFanart { get; set; }
+            public string strArtistFanart2 { get; set; }
+            public string strArtistFanart3 { get; set; }
+            public string strArtistBanner { get; set; }
+            public string strMusicBrainzID { get; set; }
+            public object strLastFMChart { get; set; }
+            public string strLocked { get; set; }
+        }
+
+        public class RootObject
+        {
+            public List<Artist> artists { get; set; }
+        }
+
+        /// <inheritdoc />
+        public Task<HttpResponseInfo> GetImageResponse(string url, CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/MediaBrowser.Providers/Plugins/AudioDb/Configuration/PluginConfiguration.cs b/MediaBrowser.Providers/Plugins/AudioDb/Configuration/PluginConfiguration.cs
new file mode 100644
index 000000000..ad3c7eb4b
--- /dev/null
+++ b/MediaBrowser.Providers/Plugins/AudioDb/Configuration/PluginConfiguration.cs
@@ -0,0 +1,11 @@
+using MediaBrowser.Model.Plugins;
+
+namespace MediaBrowser.Providers.Plugins.AudioDb
+{
+    public class PluginConfiguration : BasePluginConfiguration
+    {
+        public bool Enable { get; set; }
+
+        public bool ReplaceAlbumName { get; set; }
+    }
+}
diff --git a/MediaBrowser.Providers/Plugins/AudioDb/Configuration/config.html b/MediaBrowser.Providers/Plugins/AudioDb/Configuration/config.html
new file mode 100644
index 000000000..34494644d
--- /dev/null
+++ b/MediaBrowser.Providers/Plugins/AudioDb/Configuration/config.html
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>AudioDB</title>
+</head>
+<body>
+    <div data-role="page" class="page type-interior pluginConfigurationPage configPage" data-require="emby-input,emby-button,emby-checkbox">
+        <div data-role="content">
+            <div class="content-primary">
+                <form class="configForm">
+                    <label class="checkboxContainer">
+                        <input is="emby-checkbox" type="checkbox" id="enable" />
+                        <span>Enable this provider for metadata searches on artists and albums.</span>
+                    </label>
+                    <label class="checkboxContainer">
+                        <input is="emby-checkbox" type="checkbox" id="replaceAlbumName" />
+                        <span>When an album is found during a metadata search, replace the name with the value on the server.</span>
+                    </label>
+                    <br />
+                    <div>
+                        <button is="emby-button" type="submit" class="raised button-submit block"><span>Save</span></button>
+                    </div>
+                </form>
+            </div>
+        </div>
+        <script type="text/javascript">
+            var PluginConfig = {
+                pluginId: "a629c0da-fac5-4c7e-931a-7174223f14c8"
+            };
+
+            $('.configPage').on('pageshow', function () {
+                Dashboard.showLoadingMsg();
+                ApiClient.getPluginConfiguration(PluginConfig.pluginId).then(function (config) {
+                    $('#enable').checked(config.Enable);
+                    $('#replaceAlbumName').checked(config.ReplaceAlbumName);
+
+                    Dashboard.hideLoadingMsg();
+                });
+            });
+
+            $('.configForm').on('submit', function (e) {
+                Dashboard.showLoadingMsg();
+
+                var form = this;
+                ApiClient.getPluginConfiguration(PluginConfig.pluginId).then(function (config) {
+                    config.Enable = $('#enable', form).checked();
+                    config.ReplaceAlbumName = $('#replaceAlbumName', form).checked();
+
+                    ApiClient.updatePluginConfiguration(PluginConfig.pluginId, config).then(Dashboard.processPluginConfigurationUpdateResult);
+                });
+
+                return false;
+            });
+        </script>
+    </div>
+</body>
+</html>
diff --git a/MediaBrowser.Providers/Plugins/AudioDb/ExternalIds.cs b/MediaBrowser.Providers/Plugins/AudioDb/ExternalIds.cs
new file mode 100644
index 000000000..2d8cb431c
--- /dev/null
+++ b/MediaBrowser.Providers/Plugins/AudioDb/ExternalIds.cs
@@ -0,0 +1,66 @@
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+
+namespace MediaBrowser.Providers.Plugins.AudioDb
+{
+    public class AudioDbAlbumExternalId : IExternalId
+    {
+        /// <inheritdoc />
+        public string Name => "TheAudioDb";
+
+        /// <inheritdoc />
+        public string Key => MetadataProviders.AudioDbAlbum.ToString();
+
+        /// <inheritdoc />
+        public string UrlFormatString => "https://www.theaudiodb.com/album/{0}";
+
+        /// <inheritdoc />
+        public bool Supports(IHasProviderIds item) => item is MusicAlbum;
+    }
+
+    public class AudioDbOtherAlbumExternalId : IExternalId
+    {
+        /// <inheritdoc />
+        public string Name => "TheAudioDb Album";
+
+        /// <inheritdoc />
+        public string Key => MetadataProviders.AudioDbAlbum.ToString();
+
+        /// <inheritdoc />
+        public string UrlFormatString => "https://www.theaudiodb.com/album/{0}";
+
+        /// <inheritdoc />
+        public bool Supports(IHasProviderIds item) => item is Audio;
+    }
+
+    public class AudioDbArtistExternalId : IExternalId
+    {
+        /// <inheritdoc />
+        public string Name => "TheAudioDb";
+
+        /// <inheritdoc />
+        public string Key => MetadataProviders.AudioDbArtist.ToString();
+
+        /// <inheritdoc />
+        public string UrlFormatString => "https://www.theaudiodb.com/artist/{0}";
+
+        /// <inheritdoc />
+        public bool Supports(IHasProviderIds item) => item is MusicArtist;
+    }
+
+    public class AudioDbOtherArtistExternalId : IExternalId
+    {
+        /// <inheritdoc />
+        public string Name => "TheAudioDb Artist";
+
+        /// <inheritdoc />
+        public string Key => MetadataProviders.AudioDbArtist.ToString();
+
+        /// <inheritdoc />
+        public string UrlFormatString => "https://www.theaudiodb.com/artist/{0}";
+
+        /// <inheritdoc />
+        public bool Supports(IHasProviderIds item) => item is Audio || item is MusicAlbum;
+    }
+}
diff --git a/MediaBrowser.Providers/Plugins/AudioDb/Plugin.cs b/MediaBrowser.Providers/Plugins/AudioDb/Plugin.cs
new file mode 100644
index 000000000..8532c4df3
--- /dev/null
+++ b/MediaBrowser.Providers/Plugins/AudioDb/Plugin.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Plugins;
+using MediaBrowser.Model.Plugins;
+using MediaBrowser.Model.Serialization;
+
+namespace MediaBrowser.Providers.Plugins.AudioDb
+{
+    public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
+    {
+        public static Plugin Instance { get; private set; }
+
+        public override Guid Id => new Guid("a629c0da-fac5-4c7e-931a-7174223f14c8");
+
+        public override string Name => "AudioDB";
+
+        public override string Description => "Get artist and album metadata or images from AudioDB.";
+
+        public Plugin(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer)
+            : base(applicationPaths, xmlSerializer)
+        {
+            Instance = this;
+        }
+
+        public IEnumerable<PluginPageInfo> GetPages()
+        {
+            yield return new PluginPageInfo
+            {
+                Name = Name,
+                EmbeddedResourcePath = GetType().Namespace + ".Configuration.config.html"
+            };
+        }
+    }
+}