Add GPL modules

MediaBrowser.Controller/Providers/AlbumInfo.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class AlbumInfo : ItemLookupInfo
+    {
+        /// <summary>
+        /// Gets or sets the album artist.
+        /// </summary>
+        /// <value>The album artist.</value>
+        public string[] AlbumArtists { get; set; }
+
+        /// <summary>
+        /// Gets or sets the artist provider ids.
+        /// </summary>
+        /// <value>The artist provider ids.</value>
+        public Dictionary<string, string> ArtistProviderIds { get; set; }
+        public List<SongInfo> SongInfos { get; set; }
+
+        public AlbumInfo()
+        {
+            ArtistProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            SongInfos = new List<SongInfo>();
+            AlbumArtists = EmptyStringArray;
+        }
+    }
+}

MediaBrowser.Controller/Providers/ArtistInfo.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class ArtistInfo : ItemLookupInfo
+    {
+        public List<SongInfo> SongInfos { get; set; }
+
+        public ArtistInfo()
+        {
+            SongInfos = new List<SongInfo>();
+        }
+    }
+}

MediaBrowser.Controller/Providers/BookInfo.cs

@@ -0,0 +1,7 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class BookInfo : ItemLookupInfo
+    {
+        public string SeriesName { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/BoxSetInfo.cs

@@ -0,0 +1,7 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class BoxSetInfo : ItemLookupInfo
+    {
+
+    }
+}

MediaBrowser.Controller/Providers/DirectoryService.cs

@@ -0,0 +1,106 @@
+using MediaBrowser.Model.Logging;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.IO;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class DirectoryService : IDirectoryService
+    {
+        private readonly ILogger _logger;
+        private readonly IFileSystem _fileSystem;
+
+        private readonly Dictionary<string, FileSystemMetadata[]> _cache = new Dictionary<string, FileSystemMetadata[]>(StringComparer.OrdinalIgnoreCase);
+
+        private readonly Dictionary<string, FileSystemMetadata> _fileCache = new Dictionary<string, FileSystemMetadata>(StringComparer.OrdinalIgnoreCase);
+
+        private readonly Dictionary<string, List<string>> _filePathCache = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
+
+        public DirectoryService(ILogger logger, IFileSystem fileSystem)
+        {
+            _logger = logger;
+            _fileSystem = fileSystem;
+        }
+
+        public DirectoryService(IFileSystem fileSystem)
+            : this(new NullLogger(), fileSystem)
+        {
+        }
+
+        public FileSystemMetadata[] GetFileSystemEntries(string path)
+        {
+            FileSystemMetadata[] entries;
+
+            if (!_cache.TryGetValue(path, out entries))
+            {
+                //_logger.Debug("Getting files for " + path);
+
+                entries = _fileSystem.GetFileSystemEntries(path).ToArray();
+
+                //_cache.TryAdd(path, entries);
+                _cache[path] = entries;
+            }
+
+            return entries;
+        }
+
+        public List<FileSystemMetadata> GetFiles(string path)
+        {
+            var list = new List<FileSystemMetadata>();
+            var items = GetFileSystemEntries(path);
+            foreach (var item in items)
+            {
+                if (!item.IsDirectory)
+                {
+                    list.Add(item);
+                }
+            }
+            return list;
+        }
+
+        public FileSystemMetadata GetFile(string path)
+        {
+            FileSystemMetadata file;
+            if (!_fileCache.TryGetValue(path, out file))
+            {
+                file = _fileSystem.GetFileInfo(path);
+
+                if (file != null && file.Exists)
+                {
+                    //_fileCache.TryAdd(path, file);
+                    _fileCache[path] = file;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+
+            return file;
+            //return _fileSystem.GetFileInfo(path);
+        }
+
+        public List<string> GetFilePaths(string path)
+        {
+            return GetFilePaths(path, false);
+        }
+
+        public List<string> GetFilePaths(string path, bool clearCache)
+        {
+            List<string> result;
+            if (clearCache || !_filePathCache.TryGetValue(path, out result))
+            {
+                result = _fileSystem.GetFilePaths(path).ToList();
+
+                _filePathCache[path] = result;
+            }
+
+            return result;
+        }
+
+    }
+}

MediaBrowser.Controller/Providers/DynamicImageInfo.cs

@@ -0,0 +1,10 @@
+using MediaBrowser.Model.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class DynamicImageInfo
+    {
+        public string ImageId { get; set; }
+        public ImageType Type { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/DynamicImageResponse.cs

@@ -0,0 +1,36 @@
+using System;
+using System.IO;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.MediaInfo;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class DynamicImageResponse
+    {
+        public string Path { get; set; }
+        public MediaProtocol Protocol { get; set; }
+        public Stream Stream { get; set; }
+        public ImageFormat Format { get; set; }
+        public bool HasImage { get; set; }
+
+        public void SetFormatFromMimeType(string mimeType)
+        {
+            if (mimeType.EndsWith("gif", StringComparison.OrdinalIgnoreCase))
+            {
+                Format = ImageFormat.Gif;
+            }
+            else if (mimeType.EndsWith("bmp", StringComparison.OrdinalIgnoreCase))
+            {
+                Format = ImageFormat.Bmp;
+            }
+            else if (mimeType.EndsWith("png", StringComparison.OrdinalIgnoreCase))
+            {
+                Format = ImageFormat.Png;
+            }
+            else
+            {
+                Format = ImageFormat.Jpg;
+            }
+        }
+    }
+}

MediaBrowser.Controller/Providers/EpisodeInfo.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class EpisodeInfo : ItemLookupInfo
+    {
+        public Dictionary<string, string> SeriesProviderIds { get; set; }
+
+        public int? IndexNumberEnd { get; set; }
+
+        public bool IsMissingEpisode { get; set; }
+        public string SeriesDisplayOrder { get; set; }
+
+        public EpisodeInfo()
+        {
+            SeriesProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        }
+    }
+}

MediaBrowser.Controller/Providers/ExtraInfo.cs

@@ -0,0 +1,15 @@
+using MediaBrowser.Model.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class ExtraInfo
+    {
+        public string Path { get; set; }
+
+        public LocationType LocationType { get; set; }
+
+        public bool IsDownloadable { get; set; }
+
+        public ExtraType ExtraType { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/ExtraSource.cs

@@ -0,0 +1,9 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public enum ExtraSource
+    {
+        Local = 1,
+        Metadata = 2,
+        Remote = 3
+    }
+}

MediaBrowser.Controller/Providers/GameInfo.cs

@@ -0,0 +1,11 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class GameInfo : ItemLookupInfo
+    {
+        /// <summary>
+        /// Gets or sets the game system.
+        /// </summary>
+        /// <value>The game system.</value>
+        public string GameSystem { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/GameSystemInfo.cs

@@ -0,0 +1,11 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class GameSystemInfo : ItemLookupInfo
+    {
+        /// <summary>
+        /// Gets or sets the path.
+        /// </summary>
+        /// <value>The path.</value>
+        public string Path { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/ICustomMetadataProvider.cs

@@ -0,0 +1,24 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface ICustomMetadataProvider : IMetadataProvider
+    {
+    }
+
+    public interface ICustomMetadataProvider<TItemType> : IMetadataProvider<TItemType>, ICustomMetadataProvider
+        where TItemType : BaseItem
+    {
+        /// <summary>
+        /// Fetches the asynchronous.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="options">The options.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{ItemUpdateType}.</returns>
+        Task<ItemUpdateType> FetchAsync(TItemType item, MetadataRefreshOptions options, CancellationToken cancellationToken);
+    }
+}

MediaBrowser.Controller/Providers/IDirectoryService.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using MediaBrowser.Model.IO;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IDirectoryService
+    {
+        FileSystemMetadata[] GetFileSystemEntries(string path);
+        List<FileSystemMetadata> GetFiles(string path);
+        FileSystemMetadata GetFile(string path);
+
+        List<string> GetFilePaths(string path);
+        List<string> GetFilePaths(string path, bool clearCache);
+    }
+}

MediaBrowser.Controller/Providers/IDynamicImageProvider.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IDynamicImageProvider : IImageProvider
+    {
+        /// <summary>
+        /// Gets the supported images.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns>IEnumerable{ImageType}.</returns>
+        IEnumerable<ImageType> GetSupportedImages(BaseItem item);
+
+        /// <summary>
+        /// Gets the image.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{DynamicImageResponse}.</returns>
+        Task<DynamicImageResponse> GetImage(BaseItem item, ImageType type, CancellationToken cancellationToken);
+    }
+}

MediaBrowser.Controller/Providers/IExternalId.cs

@@ -0,0 +1,15 @@
+using MediaBrowser.Model.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IExternalId
+    {
+        string Name { get; }
+
+        string Key { get; }
+
+        string UrlFormatString { get; }
+
+        bool Supports(IHasProviderIds item);
+    }
+}

MediaBrowser.Controller/Providers/IExtrasProvider.cs

@@ -0,0 +1,20 @@
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IExtrasProvider
+    {
+        /// <summary>
+        /// Gets the name.
+        /// </summary>
+        /// <value>The name.</value>
+        string Name { get; }
+
+        /// <summary>
+        /// Supportses the specified item.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
+        bool Supports(BaseItem item);
+    }
+}

MediaBrowser.Controller/Providers/IForcedProvider.cs

@@ -0,0 +1,10 @@
+
+namespace MediaBrowser.Controller.Providers
+{
+    /// <summary>
+    /// This is a marker interface that will cause a provider to run even if IsLocked=true
+    /// </summary>
+    public interface IForcedProvider
+    {
+    }
+}

MediaBrowser.Controller/Providers/IHasItemChangeMonitor.cs

@@ -0,0 +1,15 @@
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IHasItemChangeMonitor
+    {
+        /// <summary>
+        /// Determines whether the specified item has changed.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="directoryService">The directory service.</param>
+        /// <returns><c>true</c> if the specified item has changed; otherwise, <c>false</c>.</returns>
+        bool HasChanged(BaseItem item, IDirectoryService directoryService);
+    }
+}

MediaBrowser.Controller/Providers/IHasLookupInfo.cs

@@ -0,0 +1,8 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IHasLookupInfo<out TLookupInfoType>
+        where TLookupInfoType : ItemLookupInfo, new()
+    {
+        TLookupInfoType GetLookupInfo();
+    }
+}

MediaBrowser.Controller/Providers/IHasOrder.cs

@@ -0,0 +1,7 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IHasOrder
+    {
+        int Order { get; }
+    }
+}

MediaBrowser.Controller/Providers/IImageEnhancer.cs

@@ -0,0 +1,61 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Drawing;
+using MediaBrowser.Model.Entities;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IImageEnhancer
+    {
+        /// <summary>
+        /// Return true only if the given image for the given item will be enhanced by this enhancer.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="imageType">Type of the image.</param>
+        /// <returns><c>true</c> if this enhancer will enhance the supplied image for the supplied item, <c>false</c> otherwise</returns>
+        bool Supports(BaseItem item, ImageType imageType);
+
+        /// <summary>
+        /// Gets the priority or order in which this enhancer should be run.
+        /// </summary>
+        /// <value>The priority.</value>
+        MetadataProviderPriority Priority { get; }
+
+        /// <summary>
+        /// Return a key incorporating all configuration information related to this item
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="imageType">Type of the image.</param>
+        /// <returns>Cache key relating to the current state of this item and configuration</returns>
+        string GetConfigurationCacheKey(BaseItem item, ImageType imageType);
+
+        /// <summary>
+        /// Gets the size of the enhanced image.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="imageType">Type of the image.</param>
+        /// <param name="imageIndex">Index of the image.</param>
+        /// <param name="originalImageSize">Size of the original image.</param>
+        /// <returns>ImageSize.</returns>
+        ImageSize GetEnhancedImageSize(BaseItem item, ImageType imageType, int imageIndex, ImageSize originalImageSize);
+
+        EnhancedImageInfo GetEnhancedImageInfo(BaseItem item, string inputFile, ImageType imageType, int imageIndex);
+
+        /// <summary>
+        /// Enhances the image async.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="inputFile">The input file.</param>
+        /// <param name="outputFile">The output file.</param>
+        /// <param name="imageType">Type of the image.</param>
+        /// <param name="imageIndex">Index of the image.</param>
+        /// <returns>Task{Image}.</returns>
+        /// <exception cref="System.ArgumentNullException"></exception>
+        Task EnhanceImageAsync(BaseItem item, string inputFile, string outputFile, ImageType imageType, int imageIndex);
+    }
+
+    public class EnhancedImageInfo
+    {
+        public bool RequiresTransparency { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/IImageProvider.cs

@@ -0,0 +1,23 @@
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    /// <summary>
+    /// Interface IImageProvider
+    /// </summary>
+    public interface IImageProvider
+    {
+        /// <summary>
+        /// Gets the name.
+        /// </summary>
+        /// <value>The name.</value>
+        string Name { get; }
+
+        /// <summary>
+        /// Supportses the specified item.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
+        bool Supports(BaseItem item);
+    }
+}

MediaBrowser.Controller/Providers/ILocalImageFileProvider.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface ILocalImageFileProvider : ILocalImageProvider
+    {
+        List<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService);
+    }
+}

MediaBrowser.Controller/Providers/ILocalImageProvider.cs

@@ -0,0 +1,9 @@
+namespace MediaBrowser.Controller.Providers
+{
+    /// <summary>
+    /// This is just a marker interface
+    /// </summary>
+    public interface ILocalImageProvider : IImageProvider
+    {
+    }
+}

MediaBrowser.Controller/Providers/ILocalMetadataProvider.cs

@@ -0,0 +1,25 @@
+using MediaBrowser.Controller.Entities;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface ILocalMetadataProvider : IMetadataProvider
+    {
+    }
+
+    public interface ILocalMetadataProvider<TItemType> : IMetadataProvider<TItemType>, ILocalMetadataProvider
+         where TItemType : BaseItem
+    {
+        /// <summary>
+        /// Gets the metadata.
+        /// </summary>
+        /// <param name="info">The information.</param>
+        /// <param name="directoryService">The directory service.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{MetadataResult{`0}}.</returns>
+        Task<MetadataResult<TItemType>> GetMetadata(ItemInfo info, 
+            IDirectoryService directoryService,
+            CancellationToken cancellationToken);
+    }
+}

MediaBrowser.Controller/Providers/IMetadataProvider.cs

@@ -0,0 +1,21 @@
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    /// <summary>
+    /// Marker interface
+    /// </summary>
+    public interface IMetadataProvider
+    {
+        /// <summary>
+        /// Gets the name.
+        /// </summary>
+        /// <value>The name.</value>
+        string Name { get; }
+    }
+
+    public interface IMetadataProvider<TItemType> : IMetadataProvider
+           where TItemType : BaseItem
+    {
+    }
+}

MediaBrowser.Controller/Providers/IMetadataService.cs

@@ -0,0 +1,34 @@
+using System;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IMetadataService
+    {
+        /// <summary>
+        /// Determines whether this instance can refresh the specified item.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns><c>true</c> if this instance can refresh the specified item; otherwise, <c>false</c>.</returns>
+        bool CanRefresh(BaseItem item);
+        bool CanRefreshPrimary(Type type);
+
+        /// <summary>
+        /// Refreshes the metadata.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="refreshOptions">The options.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        Task<ItemUpdateType> RefreshMetadata(BaseItem item, MetadataRefreshOptions refreshOptions, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Gets the order.
+        /// </summary>
+        /// <value>The order.</value>
+        int Order { get; }
+    }
+}

MediaBrowser.Controller/Providers/IPreRefreshProvider.cs

@@ -0,0 +1,7 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IPreRefreshProvider : ICustomMetadataProvider
+    {
+        
+    }
+}

MediaBrowser.Controller/Providers/IProviderManager.cs

@@ -0,0 +1,178 @@
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Events;
+
+namespace MediaBrowser.Controller.Providers
+{
+    /// <summary>
+    /// Interface IProviderManager
+    /// </summary>
+    public interface IProviderManager
+    {
+        /// <summary>
+        /// Queues the refresh.
+        /// </summary>
+        void QueueRefresh(Guid itemId, MetadataRefreshOptions options, RefreshPriority priority);
+
+        /// <summary>
+        /// Refreshes the full item.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="options">The options.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        Task RefreshFullItem(BaseItem item, MetadataRefreshOptions options, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Refreshes the metadata.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="options">The options.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        Task<ItemUpdateType> RefreshSingleItem(BaseItem item, MetadataRefreshOptions options, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Saves the image.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="url">The URL.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="imageIndex">Index of the image.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        Task SaveImage(BaseItem item, string url, ImageType type, int? imageIndex, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Saves the image.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="source">The source.</param>
+        /// <param name="mimeType">Type of the MIME.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="imageIndex">Index of the image.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        Task SaveImage(BaseItem item, Stream source, string mimeType, ImageType type, int? imageIndex, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Saves the image.
+        /// </summary>
+        /// <returns>Task.</returns>
+        Task SaveImage(BaseItem item, string source, string mimeType, ImageType type, int? imageIndex, bool? saveLocallyWithMedia, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Adds the metadata providers.
+        /// </summary>
+        void AddParts(IEnumerable<IImageProvider> imageProviders, IEnumerable<IMetadataService> metadataServices, IEnumerable<IMetadataProvider> metadataProviders,
+            IEnumerable<IMetadataSaver> savers,
+            IEnumerable<IExternalId> externalIds);
+
+        /// <summary>
+        /// Gets the available remote images.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="query">The query.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{IEnumerable{RemoteImageInfo}}.</returns>
+        Task<IEnumerable<RemoteImageInfo>> GetAvailableRemoteImages(BaseItem item, RemoteImageQuery query, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Gets the image providers.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns>IEnumerable{ImageProviderInfo}.</returns>
+        IEnumerable<ImageProviderInfo> GetRemoteImageProviderInfo(BaseItem item);
+
+        /// <summary>
+        /// Gets all metadata plugins.
+        /// </summary>
+        /// <returns>IEnumerable{MetadataPlugin}.</returns>
+        MetadataPluginSummary[] GetAllMetadataPlugins();
+
+        /// <summary>
+        /// Gets the external urls.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns>IEnumerable{ExternalUrl}.</returns>
+        IEnumerable<ExternalUrl> GetExternalUrls(BaseItem item);
+
+        /// <summary>
+        /// Gets the external identifier infos.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns>IEnumerable{ExternalIdInfo}.</returns>
+        IEnumerable<ExternalIdInfo> GetExternalIdInfos(IHasProviderIds item);
+
+        /// <summary>
+        /// Saves the metadata.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="updateType">Type of the update.</param>
+        /// <returns>Task.</returns>
+        void SaveMetadata(BaseItem item, ItemUpdateType updateType);
+
+        /// <summary>
+        /// Saves the metadata.
+        /// </summary>
+        void SaveMetadata(BaseItem item, ItemUpdateType updateType, IEnumerable<string> savers);
+
+        /// <summary>
+        /// Gets the metadata options.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns>MetadataOptions.</returns>
+        MetadataOptions GetMetadataOptions(BaseItem item);
+
+        /// <summary>
+        /// Gets the remote search results.
+        /// </summary>
+        /// <typeparam name="TItemType">The type of the t item type.</typeparam>
+        /// <typeparam name="TLookupType">The type of the t lookup type.</typeparam>
+        /// <param name="searchInfo">The search information.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{IEnumerable{SearchResult{``1}}}.</returns>
+        Task<IEnumerable<RemoteSearchResult>> GetRemoteSearchResults<TItemType, TLookupType>(
+            RemoteSearchQuery<TLookupType> searchInfo,
+            CancellationToken cancellationToken)
+            where TItemType : BaseItem, new()
+            where TLookupType : ItemLookupInfo;
+
+        /// <summary>
+        /// Gets the search image.
+        /// </summary>
+        /// <param name="providerName">Name of the provider.</param>
+        /// <param name="url">The URL.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{HttpResponseInfo}.</returns>
+        Task<HttpResponseInfo> GetSearchImage(string providerName, string url, CancellationToken cancellationToken);
+
+        Dictionary<Guid, Guid> GetRefreshQueue();
+
+        void OnRefreshStart(BaseItem item);
+        void OnRefreshProgress(BaseItem item, double progress);
+        void OnRefreshComplete(BaseItem item);
+
+        double? GetRefreshProgress(Guid id);
+
+        event EventHandler<GenericEventArgs<BaseItem>> RefreshStarted;
+        event EventHandler<GenericEventArgs<BaseItem>> RefreshCompleted;
+        event EventHandler<GenericEventArgs<Tuple<BaseItem, double>>> RefreshProgress;
+    }
+
+    public enum RefreshPriority
+    {
+        High = 0,
+        Normal = 1,
+        Low = 2
+    }
+}

MediaBrowser.Controller/Providers/IRemoteImageProvider.cs

@@ -0,0 +1,39 @@
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Controller.Providers
+{
+    /// <summary>
+    /// Interface IImageProvider
+    /// </summary>
+    public interface IRemoteImageProvider : IImageProvider
+    {
+        /// <summary>
+        /// Gets the supported images.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <returns>IEnumerable{ImageType}.</returns>
+        IEnumerable<ImageType> GetSupportedImages(BaseItem item);
+        
+        /// <summary>
+        /// Gets the images.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{IEnumerable{RemoteImageInfo}}.</returns>
+        Task<IEnumerable<RemoteImageInfo>> GetImages(BaseItem item, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Gets the image response.
+        /// </summary>
+        /// <param name="url">The URL.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{HttpResponseInfo}.</returns>
+        Task<HttpResponseInfo> GetImageResponse(string url, CancellationToken cancellationToken);
+    }
+}

MediaBrowser.Controller/Providers/IRemoteMetadataProvider.cs

@@ -0,0 +1,25 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Providers;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IRemoteMetadataProvider : IMetadataProvider
+    {
+    }
+
+    public interface IRemoteMetadataProvider<TItemType, in TLookupInfoType> : IMetadataProvider<TItemType>, IRemoteMetadataProvider, IRemoteSearchProvider<TLookupInfoType>
+        where TItemType : BaseItem, IHasLookupInfo<TLookupInfoType>
+        where TLookupInfoType : ItemLookupInfo, new()
+    {
+        Task<MetadataResult<TItemType>> GetMetadata(TLookupInfoType info, CancellationToken cancellationToken);
+    }
+
+    public interface IRemoteSearchProvider<in TLookupInfoType> : IRemoteSearchProvider
+        where TLookupInfoType : ItemLookupInfo
+    {
+        Task<IEnumerable<RemoteSearchResult>> GetSearchResults(TLookupInfoType searchInfo, CancellationToken cancellationToken);
+    }
+}

MediaBrowser.Controller/Providers/IRemoteSearchProvider.cs

@@ -0,0 +1,17 @@
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Common.Net;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public interface IRemoteSearchProvider : IMetadataProvider
+    {
+        /// <summary>
+        /// Gets the image response.
+        /// </summary>
+        /// <param name="url">The URL.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task{HttpResponseInfo}.</returns>
+        Task<HttpResponseInfo> GetImageResponse(string url, CancellationToken cancellationToken);
+    }
+}

MediaBrowser.Controller/Providers/ImageRefreshOptions.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using MediaBrowser.Model.Entities;
+using System;
+using System.Linq;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class ImageRefreshOptions
+    {
+        public MetadataRefreshMode ImageRefreshMode { get; set; }
+        public IDirectoryService DirectoryService { get; private set; }
+
+        public bool ReplaceAllImages { get; set; }
+
+        public ImageType[] ReplaceImages { get; set; }
+        public bool IsAutomated { get; set; }
+
+        public ImageRefreshOptions(IDirectoryService directoryService)
+        {
+            ImageRefreshMode = MetadataRefreshMode.Default;
+            DirectoryService = directoryService;
+
+            ReplaceImages = new ImageType[] { };
+            IsAutomated = true;
+        }
+
+        public bool IsReplacingImage(ImageType type)
+        {
+            return ImageRefreshMode == MetadataRefreshMode.FullRefresh &&
+                   (ReplaceAllImages || ReplaceImages.Contains(type));
+        }
+    }
+}

MediaBrowser.Controller/Providers/ItemInfo.cs

@@ -0,0 +1,32 @@
+using System;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Entities;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class ItemInfo
+    {
+        public ItemInfo(BaseItem item)
+        {
+            Path = item.Path;
+            ContainingFolderPath = item.ContainingFolderPath;
+            IsInMixedFolder = item.IsInMixedFolder;
+
+            var video = item as Video;
+            if (video != null)
+            {
+                VideoType = video.VideoType;
+                IsPlaceHolder = video.IsPlaceHolder;
+            }
+
+            ItemType = item.GetType();
+        }
+
+        public Type ItemType { get; set; }
+        public string Path { get; set; }
+        public string ContainingFolderPath { get; set; }
+        public VideoType VideoType { get; set; }
+        public bool IsInMixedFolder { get; set; }
+        public bool IsPlaceHolder { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/ItemLookupInfo.cs

@@ -0,0 +1,47 @@
+using MediaBrowser.Model.Entities;
+using System;
+using System.Collections.Generic;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class ItemLookupInfo : IHasProviderIds
+    {
+        protected static string[] EmptyStringArray = new string[] { };
+        
+        /// <summary>
+        /// Gets or sets the name.
+        /// </summary>
+        /// <value>The name.</value>
+        public string Name { get; set; }
+        /// <summary>
+        /// Gets or sets the metadata language.
+        /// </summary>
+        /// <value>The metadata language.</value>
+        public string MetadataLanguage { get; set; }
+        /// <summary>
+        /// Gets or sets the metadata country code.
+        /// </summary>
+        /// <value>The metadata country code.</value>
+        public string MetadataCountryCode { get; set; }
+        /// <summary>
+        /// Gets or sets the provider ids.
+        /// </summary>
+        /// <value>The provider ids.</value>
+        public Dictionary<string, string> ProviderIds { get; set; }
+        /// <summary>
+        /// Gets or sets the year.
+        /// </summary>
+        /// <value>The year.</value>
+        public int? Year { get; set; }
+        public int? IndexNumber { get; set; }
+        public int? ParentIndexNumber { get; set; }
+        public DateTime? PremiereDate { get; set; }
+        public bool IsAutomated { get; set; }
+
+        public ItemLookupInfo()
+        {
+            IsAutomated = true;
+            ProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        }
+    }
+}

MediaBrowser.Controller/Providers/LocalImageInfo.cs

@@ -0,0 +1,13 @@
+
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class LocalImageInfo
+    {
+        public FileSystemMetadata FileInfo { get; set; }
+        public ImageType Type { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/MetadataProviderPriority.cs

@@ -0,0 +1,40 @@
+
+namespace MediaBrowser.Controller.Providers
+{
+    /// <summary>
+    /// Determines when a provider should execute, relative to others
+    /// </summary>
+    public enum MetadataProviderPriority
+    {
+        // Run this provider at the beginning
+        /// <summary>
+        /// The first
+        /// </summary>
+        First = 1,
+
+        // Run this provider after all first priority providers
+        /// <summary>
+        /// The second
+        /// </summary>
+        Second = 2,
+
+        // Run this provider after all second priority providers
+        /// <summary>
+        /// The third
+        /// </summary>
+        Third = 3,
+
+        /// <summary>
+        /// The fourth
+        /// </summary>
+        Fourth = 4,
+
+        Fifth = 5,
+
+        // Run this provider last
+        /// <summary>
+        /// The last
+        /// </summary>
+        Last = 999
+    }
+}

MediaBrowser.Controller/Providers/MetadataRefreshMode.cs

@@ -0,0 +1,25 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public enum MetadataRefreshMode
+    {
+        /// <summary>
+        /// The none
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// The validation only
+        /// </summary>
+        ValidationOnly = 1,
+
+        /// <summary>
+        /// Providers will be executed based on default rules
+        /// </summary>
+        Default = 2,
+
+        /// <summary>
+        /// All providers will be executed to search for new metadata
+        /// </summary>
+        FullRefresh = 3
+    }
+}

MediaBrowser.Controller/Providers/MetadataRefreshOptions.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Providers;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class MetadataRefreshOptions : ImageRefreshOptions
+    {
+        /// <summary>
+        /// When paired with MetadataRefreshMode=FullRefresh, all existing data will be overwritten with new data from the providers.
+        /// </summary>
+        public bool ReplaceAllMetadata { get; set; }
+
+        public MetadataRefreshMode MetadataRefreshMode { get; set; }
+        public RemoteSearchResult SearchResult { get; set; }
+
+        public string[] RefreshPaths { get; set; }
+
+        public bool ForceSave { get; set; }
+        public bool EnableRemoteContentProbe { get; set; }
+
+        public MetadataRefreshOptions(IFileSystem fileSystem)
+			: this(new DirectoryService(new NullLogger(), fileSystem))
+        {
+        }
+
+        public MetadataRefreshOptions(IDirectoryService directoryService)
+            : base(directoryService)
+        {
+            MetadataRefreshMode = MetadataRefreshMode.Default;
+        }
+
+        public MetadataRefreshOptions(MetadataRefreshOptions copy)
+            : base(copy.DirectoryService)
+        {
+            MetadataRefreshMode = copy.MetadataRefreshMode;
+            ForceSave = copy.ForceSave;
+            ReplaceAllMetadata = copy.ReplaceAllMetadata;
+            EnableRemoteContentProbe = copy.EnableRemoteContentProbe;
+
+            ImageRefreshMode = copy.ImageRefreshMode;
+            ReplaceAllImages = copy.ReplaceAllImages;
+            ReplaceImages = copy.ReplaceImages;
+            SearchResult = copy.SearchResult;
+
+            if (copy.RefreshPaths != null && copy.RefreshPaths.Length > 0)
+            {
+                if (RefreshPaths == null)
+                {
+                    RefreshPaths = new string[] { };
+                }
+
+                RefreshPaths = copy.RefreshPaths.ToArray();
+            }
+        }
+
+        public bool RefreshItem(BaseItem item)
+        {
+            if (RefreshPaths != null && RefreshPaths.Length > 0)
+            {
+                return RefreshPaths.Contains(item.Path ?? string.Empty, StringComparer.OrdinalIgnoreCase);
+            }
+
+            return true;
+        }
+    }
+}

MediaBrowser.Controller/Providers/MetadataResult.cs

@@ -0,0 +1,77 @@
+using MediaBrowser.Controller.Entities;
+using System;
+using System.Collections.Generic;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class MetadataResult<T>
+    {
+        public List<LocalImageInfo> Images { get; set; }
+        public List<UserItemData> UserDataList { get; set; }
+
+        public MetadataResult()
+        {
+            Images = new List<LocalImageInfo>();
+            ResultLanguage = "en";
+        }
+
+        public List<PersonInfo> People { get; set; }
+
+        public bool HasMetadata { get; set; }
+        public T Item { get; set; }
+        public string ResultLanguage { get; set; }
+        public string Provider { get; set; }
+        public bool QueriedById { get; set; }
+        public void AddPerson(PersonInfo p)
+        {
+            if (People == null)
+            {
+                People = new List<PersonInfo>();
+            }
+
+            PeopleHelper.AddPerson(People, p);
+        }
+
+        /// <summary>
+        /// Not only does this clear, but initializes the list so that services can differentiate between a null list and zero people
+        /// </summary>
+        public void ResetPeople()
+        {
+            if (People == null)
+            {
+                People = new List<PersonInfo>();
+            }
+            People.Clear();
+        }
+
+        public UserItemData GetOrAddUserData(string userId)
+        {
+            if (UserDataList == null)
+            {
+                UserDataList = new List<UserItemData>();
+            }
+
+            UserItemData userData = null;
+
+            foreach (var i in UserDataList)
+            {
+                if (string.Equals(userId, i.UserId.ToString("N"), StringComparison.OrdinalIgnoreCase))
+                {
+                    userData = i;
+                }
+            }
+
+            if (userData == null)
+            {
+                userData = new UserItemData()
+                {
+                    UserId = new Guid(userId)
+                };
+
+                UserDataList.Add(userData);
+            }
+
+            return userData;
+        }
+    }
+}

MediaBrowser.Controller/Providers/MovieInfo.cs

@@ -0,0 +1,7 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class MovieInfo : ItemLookupInfo
+    {
+
+    }
+}

MediaBrowser.Controller/Providers/MusicVideoInfo.cs

@@ -0,0 +1,7 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class MusicVideoInfo : ItemLookupInfo
+    {
+        public string[] Artists { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/PersonLookupInfo.cs

@@ -0,0 +1,7 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class PersonLookupInfo : ItemLookupInfo
+    {
+
+    }
+}

MediaBrowser.Controller/Providers/RemoteSearchQuery.cs

@@ -0,0 +1,21 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class RemoteSearchQuery<T>
+        where T : ItemLookupInfo
+    {
+        public T SearchInfo { get; set; }
+
+        public string ItemId { get; set; }
+
+        /// <summary>
+        /// If set will only search within the given provider
+        /// </summary>
+        public string SearchProviderName { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether [include disabled providers].
+        /// </summary>
+        /// <value><c>true</c> if [include disabled providers]; otherwise, <c>false</c>.</value>
+        public bool IncludeDisabledProviders { get; set; }
+    }
+}

MediaBrowser.Controller/Providers/SeasonInfo.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class SeasonInfo : ItemLookupInfo
+    {
+        public Dictionary<string, string> SeriesProviderIds { get; set; }
+
+        public SeasonInfo()
+        {
+            SeriesProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        }
+    }
+}

MediaBrowser.Controller/Providers/SeriesInfo.cs

@@ -0,0 +1,6 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class SeriesInfo : ItemLookupInfo
+    {
+    }
+}

MediaBrowser.Controller/Providers/SongInfo.cs

@@ -0,0 +1,16 @@
+
+namespace MediaBrowser.Controller.Providers
+{
+    public class SongInfo : ItemLookupInfo
+    {
+        public string[] AlbumArtists { get; set; }
+        public string Album { get; set; }
+        public string[] Artists { get; set; }
+
+        public SongInfo()
+        {
+            Artists = EmptyStringArray;
+            AlbumArtists = EmptyStringArray;
+        }
+    }
+}

MediaBrowser.Controller/Providers/TrailerInfo.cs

@@ -0,0 +1,6 @@
+namespace MediaBrowser.Controller.Providers
+{
+    public class TrailerInfo : ItemLookupInfo
+    {
+    }
+}

MediaBrowser.Controller/Providers/VideoContentType.cs

@@ -0,0 +1,19 @@
+
+namespace MediaBrowser.Controller.Providers
+{
+    /// <summary>
+    /// Enum VideoContentType
+    /// </summary>
+    public enum VideoContentType
+    {
+        /// <summary>
+        /// The episode
+        /// </summary>
+        Episode = 0,
+
+        /// <summary>
+        /// The movie
+        /// </summary>
+        Movie = 1
+    }
+}