#nullable disable
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.LiveTv;
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Configuration;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.MediaInfo;
using MediaBrowser.Model.Net;
using MediaBrowser.Model.Providers;
using Microsoft.Extensions.Logging;
namespace MediaBrowser.Providers.Manager
{
///
/// Utilities for managing images attached to items.
///
public class ItemImageProvider
{
private readonly ILogger _logger;
private readonly IProviderManager _providerManager;
private readonly IFileSystem _fileSystem;
///
/// Image types that are only one per item.
///
private static readonly ImageType[] _singularImages =
{
ImageType.Primary,
ImageType.Art,
ImageType.Banner,
ImageType.Box,
ImageType.BoxRear,
ImageType.Disc,
ImageType.Logo,
ImageType.Menu,
ImageType.Thumb
};
///
/// Initializes a new instance of the class.
///
/// The logger.
/// The provider manager for interacting with provider image references.
/// The filesystem.
public ItemImageProvider(ILogger logger, IProviderManager providerManager, IFileSystem fileSystem)
{
_logger = logger;
_providerManager = providerManager;
_fileSystem = fileSystem;
}
///
/// Verifies existing images have valid paths and adds any new local images provided.
///
/// The to validate images for.
/// The providers to use, must include (s) for local scanning.
/// The directory service for s to use.
/// true if changes were made to the item; otherwise false.
public bool ValidateImages(BaseItem item, IEnumerable providers, IDirectoryService directoryService)
{
var hasChanges = false;
if (item is not Photo)
{
var images = providers.OfType()
.SelectMany(i => i.GetImages(item, directoryService))
.ToList();
if (MergeImages(item, images))
{
hasChanges = true;
}
}
return hasChanges;
}
///
/// Refreshes from the providers according to the given options.
///
/// The to gather images for.
/// The library options.
/// The providers to query for images.
/// The refresh options.
/// The cancellation token.
/// The refresh result.
public async Task RefreshImages(
BaseItem item,
LibraryOptions libraryOptions,
List providers,
ImageRefreshOptions refreshOptions,
CancellationToken cancellationToken)
{
List oldBackdropImages = new List();
if (refreshOptions.IsReplacingImage(ImageType.Backdrop))
{
oldBackdropImages = item.GetImages(ImageType.Backdrop).ToList();
}
List oldScreenshotImages = new List();
if (refreshOptions.IsReplacingImage(ImageType.Screenshot))
{
oldScreenshotImages = item.GetImages(ImageType.Screenshot).ToList();
}
var result = new RefreshResult { UpdateType = ItemUpdateType.None };
var typeName = item.GetType().Name;
var typeOptions = libraryOptions.GetTypeOptions(typeName) ?? new TypeOptions { Type = typeName };
// track library limits, adding buffer to allow lazy replacing of current images
var backdropLimit = typeOptions.GetLimit(ImageType.Backdrop) + oldBackdropImages.Count;
var screenshotLimit = typeOptions.GetLimit(ImageType.Screenshot) + oldScreenshotImages.Count;
var downloadedImages = new List();
foreach (var provider in providers)
{
if (provider is IRemoteImageProvider remoteProvider)
{
await RefreshFromProvider(item, remoteProvider, refreshOptions, typeOptions, backdropLimit, screenshotLimit, downloadedImages, result, cancellationToken).ConfigureAwait(false);
continue;
}
if (provider is IDynamicImageProvider dynamicImageProvider)
{
await RefreshFromProvider(item, dynamicImageProvider, refreshOptions, typeOptions, downloadedImages, result, cancellationToken).ConfigureAwait(false);
}
}
// only delete existing multi-images if new ones were added
if (oldBackdropImages.Count > 0 && oldBackdropImages.Count < item.GetImages(ImageType.Backdrop).Count())
{
PruneImages(item, oldBackdropImages);
}
if (oldScreenshotImages.Count > 0 && oldScreenshotImages.Count < item.GetImages(ImageType.Screenshot).Count())
{
PruneImages(item, oldScreenshotImages);
}
return result;
}
///
/// Refreshes from a dynamic provider.
///
private async Task RefreshFromProvider(
BaseItem item,
IDynamicImageProvider provider,
ImageRefreshOptions refreshOptions,
TypeOptions savedOptions,
ICollection downloadedImages,
RefreshResult result,
CancellationToken cancellationToken)
{
try
{
var images = provider.GetSupportedImages(item);
foreach (var imageType in images)
{
if (!IsEnabled(savedOptions, imageType))
{
continue;
}
if (!HasImage(item, imageType) || (refreshOptions.IsReplacingImage(imageType) && !downloadedImages.Contains(imageType)))
{
_logger.LogDebug("Running {0} for {1}", provider.GetType().Name, item.Path ?? item.Name);
var response = await provider.GetImage(item, imageType, cancellationToken).ConfigureAwait(false);
if (response.HasImage)
{
if (!string.IsNullOrEmpty(response.Path))
{
if (response.Protocol == MediaProtocol.Http)
{
_logger.LogDebug("Setting image url into item {0}", item.Id);
var index = item.AllowsMultipleImages(imageType) ? item.GetImages(imageType).Count() : 0;
item.SetImage(
new ItemImageInfo
{
Path = response.Path,
Type = imageType
},
index);
}
else
{
var mimeType = MimeTypes.GetMimeType(response.Path);
var stream = AsyncFile.OpenRead(response.Path);
await _providerManager.SaveImage(item, stream, mimeType, imageType, null, cancellationToken).ConfigureAwait(false);
}
}
else
{
var mimeType = "image/" + response.Format.ToString().ToLowerInvariant();
await _providerManager.SaveImage(item, response.Stream, mimeType, imageType, null, cancellationToken).ConfigureAwait(false);
}
downloadedImages.Add(imageType);
result.UpdateType |= ItemUpdateType.ImageUpdate;
}
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
_logger.LogError(ex, "Error in {provider}", provider.Name);
}
}
private bool HasImage(BaseItem item, ImageType type)
{
return item.HasImage(type);
}
///
/// Determines if an item already contains the given images.
///
/// The item.
/// The images.
/// The saved options.
/// The backdrop limit.
/// The screenshot limit.
/// true if the specified item contains images; otherwise, false.
private bool ContainsImages(BaseItem item, List images, TypeOptions savedOptions, int backdropLimit, int screenshotLimit)
{
// Using .Any causes the creation of a DisplayClass aka. variable capture
for (var i = 0; i < _singularImages.Length; i++)
{
var type = _singularImages[i];
if (images.Contains(type) && !HasImage(item, type) && savedOptions.GetLimit(type) > 0)
{
return false;
}
}
if (images.Contains(ImageType.Backdrop) && item.GetImages(ImageType.Backdrop).Count() < backdropLimit)
{
return false;
}
if (images.Contains(ImageType.Screenshot) && item.GetImages(ImageType.Screenshot).Count() < screenshotLimit)
{
return false;
}
return true;
}
///
/// Refreshes from a remote provider.
///
/// The item.
/// The provider.
/// The refresh options.
/// The saved options.
/// The backdrop limit.
/// The screenshot limit.
/// The downloaded images.
/// The result.
/// The cancellation token.
/// Task.
private async Task RefreshFromProvider(
BaseItem item,
IRemoteImageProvider provider,
ImageRefreshOptions refreshOptions,
TypeOptions savedOptions,
int backdropLimit,
int screenshotLimit,
ICollection downloadedImages,
RefreshResult result,
CancellationToken cancellationToken)
{
try
{
if (!item.SupportsRemoteImageDownloading)
{
return;
}
if (!refreshOptions.ReplaceAllImages &&
refreshOptions.ReplaceImages.Length == 0 &&
ContainsImages(item, provider.GetSupportedImages(item).ToList(), savedOptions, backdropLimit, screenshotLimit))
{
return;
}
_logger.LogDebug("Running {0} for {1}", provider.GetType().Name, item.Path ?? item.Name);
var images = await _providerManager.GetAvailableRemoteImages(
item,
new RemoteImageQuery(provider.Name)
{
IncludeAllLanguages = true,
IncludeDisabledProviders = false,
},
cancellationToken).ConfigureAwait(false);
var list = images.ToList();
int minWidth;
foreach (var imageType in _singularImages)
{
if (!IsEnabled(savedOptions, imageType))
{
continue;
}
if (!HasImage(item, imageType) || (refreshOptions.IsReplacingImage(imageType) && !downloadedImages.Contains(imageType)))
{
minWidth = savedOptions.GetMinWidth(imageType);
var downloaded = await DownloadImage(item, provider, result, list, minWidth, imageType, cancellationToken).ConfigureAwait(false);
if (downloaded)
{
downloadedImages.Add(imageType);
}
}
}
minWidth = savedOptions.GetMinWidth(ImageType.Backdrop);
await DownloadMultiImages(item, ImageType.Backdrop, backdropLimit, provider, result, list, minWidth, cancellationToken).ConfigureAwait(false);
if (item is IHasScreenshots)
{
minWidth = savedOptions.GetMinWidth(ImageType.Screenshot);
await DownloadMultiImages(item, ImageType.Screenshot, screenshotLimit, provider, result, list, minWidth, cancellationToken).ConfigureAwait(false);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
result.ErrorMessage = ex.Message;
_logger.LogError(ex, "Error in {provider}", provider.Name);
}
}
private bool IsEnabled(TypeOptions options, ImageType type)
{
return options.IsEnabled(type);
}
private void PruneImages(BaseItem item, List images)
{
for (var i = 0; i < images.Count; i++)
{
var image = images[i];
if (image.IsLocalFile)
{
try
{
_fileSystem.DeleteFile(image.Path);
}
catch (FileNotFoundException)
{
}
}
}
item.RemoveImages(images);
}
///
/// Merges a list of images into the provided item, validating existing images and replacing them or adding new images as necessary.
///
/// The to modify.
/// The new images to place in item.
/// true if changes were made to the item; otherwise false.
public bool MergeImages(BaseItem item, IReadOnlyList images)
{
var changed = false;
for (var i = 0; i < _singularImages.Length; i++)
{
var type = _singularImages[i];
var image = GetFirstLocalImageInfoByType(images, type);
if (image != null)
{
var currentImage = item.GetImageInfo(type, 0);
if (currentImage == null)
{
item.SetImagePath(type, image.FileInfo);
changed = true;
}
else if (!string.Equals(currentImage.Path, image.FileInfo.FullName, StringComparison.OrdinalIgnoreCase))
{
item.SetImagePath(type, image.FileInfo);
changed = true;
}
else
{
var newDateModified = _fileSystem.GetLastWriteTimeUtc(image.FileInfo);
// If date changed then we need to reset saved image dimensions
if (currentImage.DateModified != newDateModified && (currentImage.Width > 0 || currentImage.Height > 0))
{
currentImage.Width = 0;
currentImage.Height = 0;
changed = true;
}
currentImage.DateModified = newDateModified;
}
}
else
{
var existing = item.GetImageInfo(type, 0);
if (existing != null)
{
if (existing.IsLocalFile && !File.Exists(existing.Path))
{
item.RemoveImage(existing);
changed = true;
}
}
}
}
if (UpdateMultiImages(item, images, ImageType.Backdrop))
{
changed = true;
}
if (item is IHasScreenshots)
{
if (UpdateMultiImages(item, images, ImageType.Screenshot))
{
changed = true;
}
}
return changed;
}
private static LocalImageInfo GetFirstLocalImageInfoByType(IReadOnlyList images, ImageType type)
{
var len = images.Count;
for (var i = 0; i < len; i++)
{
var image = images[i];
if (image.Type == type)
{
return image;
}
}
return null;
}
private bool UpdateMultiImages(BaseItem item, IReadOnlyList images, ImageType type)
{
var changed = false;
var deletedImages = item.GetImages(type).Where(i => i.IsLocalFile && !File.Exists(i.Path)).ToList();
if (deletedImages.Count > 0)
{
item.RemoveImages(deletedImages);
changed = true;
}
var newImageFileInfos = images
.Where(i => i.Type == type)
.Select(i => i.FileInfo)
.ToList();
if (item.AddImages(type, newImageFileInfos))
{
changed = true;
}
return changed;
}
private async Task DownloadImage(
BaseItem item,
IRemoteImageProvider provider,
RefreshResult result,
IEnumerable images,
int minWidth,
ImageType type,
CancellationToken cancellationToken)
{
var eligibleImages = images
.Where(i => i.Type == type && i.Width >= minWidth)
.ToList();
if (EnableImageStub(item) && eligibleImages.Count > 0)
{
SaveImageStub(item, type, eligibleImages.Select(i => i.Url));
result.UpdateType |= ItemUpdateType.ImageUpdate;
return true;
}
foreach (var image in eligibleImages)
{
var url = image.Url;
try
{
using var response = await provider.GetImageResponse(url, cancellationToken).ConfigureAwait(false);
// Sometimes providers send back bad urls. Just move to the next image
if (response.StatusCode == HttpStatusCode.NotFound || response.StatusCode == HttpStatusCode.Forbidden)
{
_logger.LogDebug("{Url} returned {StatusCode}, ignoring", url, response.StatusCode);
continue;
}
if (!response.IsSuccessStatusCode)
{
_logger.LogWarning("{Url} returned {StatusCode}, skipping all remaining requests", url, response.StatusCode);
break;
}
await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
await _providerManager.SaveImage(
item,
stream,
response.Content.Headers.ContentType.MediaType,
type,
null,
cancellationToken).ConfigureAwait(false);
result.UpdateType |= ItemUpdateType.ImageUpdate;
return true;
}
catch (HttpRequestException)
{
break;
}
}
return false;
}
private bool EnableImageStub(BaseItem item)
{
if (item is LiveTvProgram)
{
return true;
}
if (!item.IsFileProtocol)
{
return true;
}
if (item is IItemByName and not MusicArtist)
{
var hasDualAccess = item as IHasDualAccess;
if (hasDualAccess == null || hasDualAccess.IsAccessedByName)
{
return true;
}
}
// We always want to use prefetched images
return false;
}
private void SaveImageStub(BaseItem item, ImageType imageType, IEnumerable urls)
{
var newIndex = item.AllowsMultipleImages(imageType) ? item.GetImages(imageType).Count() : 0;
SaveImageStub(item, imageType, urls, newIndex);
}
private void SaveImageStub(BaseItem item, ImageType imageType, IEnumerable urls, int newIndex)
{
var path = string.Join('|', urls.Take(1));
item.SetImage(
new ItemImageInfo
{
Path = path,
Type = imageType
},
newIndex);
}
private async Task DownloadMultiImages(BaseItem item, ImageType imageType, int limit, IRemoteImageProvider provider, RefreshResult result, IEnumerable images, int minWidth, CancellationToken cancellationToken)
{
foreach (var image in images.Where(i => i.Type == imageType))
{
if (item.GetImages(imageType).Count() >= limit)
{
break;
}
if (image.Width.HasValue && image.Width.Value < minWidth)
{
continue;
}
var url = image.Url;
if (EnableImageStub(item))
{
SaveImageStub(item, imageType, new[] { url });
result.UpdateType |= ItemUpdateType.ImageUpdate;
continue;
}
try
{
using var response = await provider.GetImageResponse(url, cancellationToken).ConfigureAwait(false);
// Sometimes providers send back bad urls. Just move to the next image
if (response.StatusCode == HttpStatusCode.NotFound || response.StatusCode == HttpStatusCode.Forbidden)
{
_logger.LogDebug("{Url} returned {StatusCode}, ignoring", url, response.StatusCode);
continue;
}
if (!response.IsSuccessStatusCode)
{
_logger.LogWarning("{Url} returned {StatusCode}, skipping all remaining requests", url, response.StatusCode);
break;
}
// If there's already an image of the same file size, skip it
if (response.Content.Headers.ContentLength.HasValue)
{
try
{
if (item.GetImages(imageType).Any(i => _fileSystem.GetFileInfo(i.Path).Length == response.Content.Headers.ContentLength.Value))
{
response.Content.Dispose();
continue;
}
}
catch (IOException ex)
{
_logger.LogError(ex, "Error examining images");
}
}
await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
await _providerManager.SaveImage(
item,
stream,
response.Content.Headers.ContentType.MediaType,
imageType,
null,
cancellationToken).ConfigureAwait(false);
result.UpdateType = result.UpdateType | ItemUpdateType.ImageUpdate;
}
catch (HttpRequestException)
{
break;
}
}
}
}
}