2021-10-26 15:49:01 +02:00
|
|
|
#nullable disable
|
|
|
|
|
2019-01-13 21:03:10 +01:00
|
|
|
using System;
|
2014-01-28 19:37:01 +01:00
|
|
|
using System.Collections.Generic;
|
2014-02-02 14:36:31 +01:00
|
|
|
using System.IO;
|
2014-01-28 19:37:01 +01:00
|
|
|
using System.Linq;
|
|
|
|
using System.Net;
|
2020-11-14 22:30:34 +01:00
|
|
|
using System.Net.Http;
|
2014-01-28 19:37:01 +01:00
|
|
|
using System.Threading;
|
|
|
|
using System.Threading.Tasks;
|
2019-01-13 20:26:31 +01:00
|
|
|
using MediaBrowser.Controller.Entities;
|
2015-11-08 06:04:38 +01:00
|
|
|
using MediaBrowser.Controller.Entities.Audio;
|
2019-01-13 20:26:31 +01:00
|
|
|
using MediaBrowser.Controller.Library;
|
2016-02-26 05:09:42 +01:00
|
|
|
using MediaBrowser.Controller.LiveTv;
|
2019-01-13 20:26:31 +01:00
|
|
|
using MediaBrowser.Controller.Providers;
|
|
|
|
using MediaBrowser.Model.Configuration;
|
|
|
|
using MediaBrowser.Model.Entities;
|
|
|
|
using MediaBrowser.Model.IO;
|
2015-10-16 19:06:31 +02:00
|
|
|
using MediaBrowser.Model.MediaInfo;
|
2019-01-13 20:26:31 +01:00
|
|
|
using MediaBrowser.Model.Net;
|
|
|
|
using MediaBrowser.Model.Providers;
|
|
|
|
using Microsoft.Extensions.Logging;
|
2014-01-28 19:37:01 +01:00
|
|
|
|
|
|
|
namespace MediaBrowser.Providers.Manager
|
|
|
|
{
|
2021-10-31 02:40:15 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Utilities for managing images attached to items.
|
|
|
|
/// </summary>
|
2014-01-28 19:37:01 +01:00
|
|
|
public class ItemImageProvider
|
|
|
|
{
|
|
|
|
private readonly ILogger _logger;
|
|
|
|
private readonly IProviderManager _providerManager;
|
2014-01-31 20:55:21 +01:00
|
|
|
private readonly IFileSystem _fileSystem;
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2020-09-07 13:20:39 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Image types that are only one per item.
|
|
|
|
/// </summary>
|
2021-05-24 00:30:41 +02:00
|
|
|
private static readonly ImageType[] _singularImages =
|
2020-09-07 13:20:39 +02:00
|
|
|
{
|
|
|
|
ImageType.Primary,
|
|
|
|
ImageType.Art,
|
|
|
|
ImageType.Banner,
|
|
|
|
ImageType.Box,
|
|
|
|
ImageType.BoxRear,
|
|
|
|
ImageType.Disc,
|
|
|
|
ImageType.Logo,
|
|
|
|
ImageType.Menu,
|
|
|
|
ImageType.Thumb
|
|
|
|
};
|
|
|
|
|
2021-10-31 02:40:15 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Initializes a new instance of the <see cref="ItemImageProvider"/> class.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="logger">The logger.</param>
|
|
|
|
/// <param name="providerManager">The provider manager for interacting with provider image references.</param>
|
|
|
|
/// <param name="fileSystem">The filesystem.</param>
|
2020-01-08 17:52:50 +01:00
|
|
|
public ItemImageProvider(ILogger logger, IProviderManager providerManager, IFileSystem fileSystem)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
_logger = logger;
|
|
|
|
_providerManager = providerManager;
|
2014-02-02 14:36:31 +01:00
|
|
|
_fileSystem = fileSystem;
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
|
2021-10-31 02:40:15 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Verifies existing images have valid paths and adds any new local images provided.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The <see cref="BaseItem"/> to validate images for.</param>
|
|
|
|
/// <param name="providers">The providers to use, must include <see cref="ILocalImageProvider"/>(s) for local scanning.</param>
|
|
|
|
/// <param name="directoryService">The directory service for <see cref="ILocalImageProvider"/>s to use.</param>
|
|
|
|
/// <returns><c>true</c> if changes were made to the item; otherwise <c>false</c>.</returns>
|
2018-09-12 19:26:21 +02:00
|
|
|
public bool ValidateImages(BaseItem item, IEnumerable<IImageProvider> providers, IDirectoryService directoryService)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2015-04-11 03:42:37 +02:00
|
|
|
var hasChanges = false;
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2021-08-29 00:32:50 +02:00
|
|
|
if (item is not Photo)
|
2015-04-11 03:42:37 +02:00
|
|
|
{
|
2020-03-09 16:10:02 +01:00
|
|
|
var images = providers.OfType<ILocalImageProvider>()
|
2015-05-01 20:37:01 +02:00
|
|
|
.SelectMany(i => i.GetImages(item, directoryService))
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
if (MergeImages(item, images))
|
|
|
|
{
|
|
|
|
hasChanges = true;
|
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return hasChanges;
|
|
|
|
}
|
|
|
|
|
2021-10-31 02:40:15 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Refreshes from the providers according to the given options.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The <see cref="BaseItem"/> to gather images for.</param>
|
|
|
|
/// <param name="libraryOptions">The library options.</param>
|
|
|
|
/// <param name="providers">The providers to query for images.</param>
|
|
|
|
/// <param name="refreshOptions">The refresh options.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
/// <returns>The refresh result.</returns>
|
2020-08-07 19:26:28 +02:00
|
|
|
public async Task<RefreshResult> RefreshImages(
|
|
|
|
BaseItem item,
|
|
|
|
LibraryOptions libraryOptions,
|
|
|
|
List<IImageProvider> providers,
|
|
|
|
ImageRefreshOptions refreshOptions,
|
|
|
|
CancellationToken cancellationToken)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2021-11-02 16:16:06 +01:00
|
|
|
var oldBackdropImages = Array.Empty<ItemImageInfo>();
|
2014-06-15 04:24:04 +02:00
|
|
|
if (refreshOptions.IsReplacingImage(ImageType.Backdrop))
|
|
|
|
{
|
2021-11-02 16:16:06 +01:00
|
|
|
oldBackdropImages = item.GetImages(ImageType.Backdrop).ToArray();
|
2014-06-15 04:24:04 +02:00
|
|
|
}
|
2020-06-15 23:43:52 +02:00
|
|
|
|
2014-02-10 19:39:41 +01:00
|
|
|
var result = new RefreshResult { UpdateType = ItemUpdateType.None };
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var typeName = item.GetType().Name;
|
|
|
|
var typeOptions = libraryOptions.GetTypeOptions(typeName) ?? new TypeOptions { Type = typeName };
|
2014-01-29 06:17:58 +01:00
|
|
|
|
2021-11-01 00:16:11 +01:00
|
|
|
// track library limits, adding buffer to allow lazy replacing of current images
|
2021-11-02 16:16:06 +01:00
|
|
|
var backdropLimit = typeOptions.GetLimit(ImageType.Backdrop) + oldBackdropImages.Length;
|
2014-06-15 04:24:04 +02:00
|
|
|
var downloadedImages = new List<ImageType>();
|
2014-02-02 14:36:31 +01:00
|
|
|
|
2014-02-07 01:43:45 +01:00
|
|
|
foreach (var provider in providers)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2020-08-07 19:26:28 +02:00
|
|
|
if (provider is IRemoteImageProvider remoteProvider)
|
2014-02-07 01:43:45 +01:00
|
|
|
{
|
2021-11-05 21:31:12 +01:00
|
|
|
await RefreshFromProvider(item, remoteProvider, refreshOptions, typeOptions, backdropLimit, downloadedImages, result, cancellationToken).ConfigureAwait(false);
|
2014-02-07 01:43:45 +01:00
|
|
|
continue;
|
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2020-08-07 19:26:28 +02:00
|
|
|
if (provider is IDynamicImageProvider dynamicImageProvider)
|
2014-02-07 01:43:45 +01:00
|
|
|
{
|
2020-08-07 19:26:28 +02:00
|
|
|
await RefreshFromProvider(item, dynamicImageProvider, refreshOptions, typeOptions, downloadedImages, result, cancellationToken).ConfigureAwait(false);
|
2014-02-07 01:43:45 +01:00
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
|
2021-11-01 00:16:11 +01:00
|
|
|
// only delete existing multi-images if new ones were added
|
2021-11-02 16:16:06 +01:00
|
|
|
if (oldBackdropImages.Length > 0 && oldBackdropImages.Length < item.GetImages(ImageType.Backdrop).Count())
|
2021-11-01 00:16:11 +01:00
|
|
|
{
|
|
|
|
PruneImages(item, oldBackdropImages);
|
|
|
|
}
|
|
|
|
|
2014-01-28 19:37:01 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
2021-10-31 02:40:15 +02:00
|
|
|
/// Refreshes from a dynamic provider.
|
2014-01-28 19:37:01 +01:00
|
|
|
/// </summary>
|
2020-08-07 19:26:28 +02:00
|
|
|
private async Task RefreshFromProvider(
|
|
|
|
BaseItem item,
|
2014-06-13 16:24:14 +02:00
|
|
|
IDynamicImageProvider provider,
|
|
|
|
ImageRefreshOptions refreshOptions,
|
2018-09-12 19:26:21 +02:00
|
|
|
TypeOptions savedOptions,
|
2014-06-15 04:24:04 +02:00
|
|
|
ICollection<ImageType> downloadedImages,
|
2014-06-13 16:24:14 +02:00
|
|
|
RefreshResult result,
|
|
|
|
CancellationToken cancellationToken)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2014-01-29 17:16:24 +01:00
|
|
|
var images = provider.GetSupportedImages(item);
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2014-01-29 17:16:24 +01:00
|
|
|
foreach (var imageType in images)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2020-08-07 19:26:28 +02:00
|
|
|
if (!IsEnabled(savedOptions, imageType))
|
2020-06-20 10:35:29 +02:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2014-06-15 04:24:04 +02:00
|
|
|
|
2015-11-21 04:13:03 +01:00
|
|
|
if (!HasImage(item, imageType) || (refreshOptions.IsReplacingImage(imageType) && !downloadedImages.Contains(imageType)))
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogDebug("Running {0} for {1}", provider.GetType().Name, item.Path ?? item.Name);
|
2014-02-06 05:39:16 +01:00
|
|
|
|
2014-01-29 17:16:24 +01:00
|
|
|
var response = await provider.GetImage(item, imageType, cancellationToken).ConfigureAwait(false);
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2014-01-29 17:16:24 +01:00
|
|
|
if (response.HasImage)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2014-01-31 20:55:21 +01:00
|
|
|
if (!string.IsNullOrEmpty(response.Path))
|
|
|
|
{
|
2015-10-16 19:06:31 +02:00
|
|
|
if (response.Protocol == MediaProtocol.Http)
|
|
|
|
{
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogDebug("Setting image url into item {0}", item.Id);
|
2021-11-01 00:16:11 +01:00
|
|
|
var index = item.AllowsMultipleImages(imageType) ? item.GetImages(imageType).Count() : 0;
|
2020-08-07 19:26:28 +02:00
|
|
|
item.SetImage(
|
|
|
|
new ItemImageInfo
|
|
|
|
{
|
|
|
|
Path = response.Path,
|
|
|
|
Type = imageType
|
|
|
|
},
|
2021-11-01 00:16:11 +01:00
|
|
|
index);
|
2015-10-16 19:06:31 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
var mimeType = MimeTypes.GetMimeType(response.Path);
|
|
|
|
|
2021-10-03 19:52:38 +02:00
|
|
|
var stream = AsyncFile.OpenRead(response.Path);
|
2015-10-16 19:06:31 +02:00
|
|
|
|
2016-10-17 18:35:29 +02:00
|
|
|
await _providerManager.SaveImage(item, stream, mimeType, imageType, null, cancellationToken).ConfigureAwait(false);
|
2015-10-16 19:06:31 +02:00
|
|
|
}
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-01-27 12:03:43 +01:00
|
|
|
var mimeType = "image/" + response.Format.ToString().ToLowerInvariant();
|
2014-01-31 20:55:21 +01:00
|
|
|
|
2016-10-17 18:35:29 +02:00
|
|
|
await _providerManager.SaveImage(item, response.Stream, mimeType, imageType, null, cancellationToken).ConfigureAwait(false);
|
2014-01-31 20:55:21 +01:00
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2014-06-15 04:24:04 +02:00
|
|
|
downloadedImages.Add(imageType);
|
2020-08-07 19:26:28 +02:00
|
|
|
result.UpdateType |= ItemUpdateType.ImageUpdate;
|
2014-01-29 17:16:24 +01:00
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (OperationCanceledException)
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
result.ErrorMessage = ex.Message;
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogError(ex, "Error in {Provider}", provider.Name);
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private bool HasImage(BaseItem item, ImageType type)
|
2015-11-21 04:13:03 +01:00
|
|
|
{
|
2017-10-01 19:26:09 +02:00
|
|
|
return item.HasImage(type);
|
2015-11-21 04:13:03 +01:00
|
|
|
}
|
|
|
|
|
2014-01-28 19:37:01 +01:00
|
|
|
/// <summary>
|
2020-06-16 00:37:52 +02:00
|
|
|
/// Determines if an item already contains the given images.
|
2014-01-28 19:37:01 +01:00
|
|
|
/// </summary>
|
2014-02-02 14:36:31 +01:00
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
/// <param name="images">The images.</param>
|
|
|
|
/// <param name="savedOptions">The saved options.</param>
|
|
|
|
/// <param name="backdropLimit">The backdrop limit.</param>
|
|
|
|
/// <returns><c>true</c> if the specified item contains images; otherwise, <c>false</c>.</returns>
|
2021-11-05 21:31:12 +01:00
|
|
|
private bool ContainsImages(BaseItem item, List<ImageType> images, TypeOptions savedOptions, int backdropLimit)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2021-05-24 00:30:41 +02:00
|
|
|
// Using .Any causes the creation of a DisplayClass aka. variable capture
|
|
|
|
for (var i = 0; i < _singularImages.Length; i++)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2021-05-24 00:30:41 +02:00
|
|
|
var type = _singularImages[i];
|
|
|
|
if (images.Contains(type) && !HasImage(item, type) && savedOptions.GetLimit(type) > 0)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
|
2014-02-07 21:30:41 +01:00
|
|
|
if (images.Contains(ImageType.Backdrop) && item.GetImages(ImageType.Backdrop).Count() < backdropLimit)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
2021-10-31 02:40:15 +02:00
|
|
|
/// Refreshes from a remote provider.
|
2014-01-28 19:37:01 +01:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
/// <param name="provider">The provider.</param>
|
2014-02-02 14:36:31 +01:00
|
|
|
/// <param name="refreshOptions">The refresh options.</param>
|
|
|
|
/// <param name="savedOptions">The saved options.</param>
|
|
|
|
/// <param name="backdropLimit">The backdrop limit.</param>
|
2014-06-15 04:24:04 +02:00
|
|
|
/// <param name="downloadedImages">The downloaded images.</param>
|
2014-01-28 19:37:01 +01:00
|
|
|
/// <param name="result">The result.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
/// <returns>Task.</returns>
|
2020-04-05 18:10:56 +02:00
|
|
|
private async Task RefreshFromProvider(
|
|
|
|
BaseItem item,
|
2014-10-04 20:05:24 +02:00
|
|
|
IRemoteImageProvider provider,
|
|
|
|
ImageRefreshOptions refreshOptions,
|
2018-09-12 19:26:21 +02:00
|
|
|
TypeOptions savedOptions,
|
2014-10-04 20:05:24 +02:00
|
|
|
int backdropLimit,
|
2014-06-15 04:24:04 +02:00
|
|
|
ICollection<ImageType> downloadedImages,
|
2014-10-04 20:05:24 +02:00
|
|
|
RefreshResult result,
|
2014-06-15 04:24:04 +02:00
|
|
|
CancellationToken cancellationToken)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2014-08-14 15:24:30 +02:00
|
|
|
if (!item.SupportsRemoteImageDownloading)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-10-04 20:05:24 +02:00
|
|
|
if (!refreshOptions.ReplaceAllImages &&
|
2018-09-12 19:26:21 +02:00
|
|
|
refreshOptions.ReplaceImages.Length == 0 &&
|
2021-11-05 21:31:12 +01:00
|
|
|
ContainsImages(item, provider.GetSupportedImages(item).ToList(), savedOptions, backdropLimit))
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger.LogDebug("Running {0} for {1}", provider.GetType().Name, item.Path ?? item.Name);
|
2014-02-07 21:30:41 +01:00
|
|
|
|
2020-04-05 18:10:56 +02:00
|
|
|
var images = await _providerManager.GetAvailableRemoteImages(
|
|
|
|
item,
|
|
|
|
new RemoteImageQuery(provider.Name)
|
|
|
|
{
|
2021-09-08 23:20:11 +02:00
|
|
|
IncludeAllLanguages = true,
|
2020-04-05 18:10:56 +02:00
|
|
|
IncludeDisabledProviders = false,
|
|
|
|
},
|
|
|
|
cancellationToken).ConfigureAwait(false);
|
2014-02-12 04:46:27 +01:00
|
|
|
|
2014-01-28 19:37:01 +01:00
|
|
|
var list = images.ToList();
|
2014-02-12 04:33:30 +01:00
|
|
|
int minWidth;
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2014-06-15 04:24:04 +02:00
|
|
|
foreach (var imageType in _singularImages)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2020-08-07 19:26:28 +02:00
|
|
|
if (!IsEnabled(savedOptions, imageType))
|
2020-04-05 18:10:56 +02:00
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
2014-06-15 04:24:04 +02:00
|
|
|
|
2015-11-21 04:13:03 +01:00
|
|
|
if (!HasImage(item, imageType) || (refreshOptions.IsReplacingImage(imageType) && !downloadedImages.Contains(imageType)))
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2014-06-15 04:24:04 +02:00
|
|
|
minWidth = savedOptions.GetMinWidth(imageType);
|
2021-06-27 02:00:17 +02:00
|
|
|
var downloaded = await DownloadImage(item, provider, result, list, minWidth, imageType, cancellationToken).ConfigureAwait(false);
|
2014-06-15 04:24:04 +02:00
|
|
|
|
|
|
|
if (downloaded)
|
|
|
|
{
|
|
|
|
downloadedImages.Add(imageType);
|
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
minWidth = savedOptions.GetMinWidth(ImageType.Backdrop);
|
2021-11-02 00:31:59 +01:00
|
|
|
await DownloadMultiImages(item, ImageType.Backdrop, refreshOptions, backdropLimit, provider, result, list, minWidth, cancellationToken).ConfigureAwait(false);
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
catch (OperationCanceledException)
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
result.ErrorMessage = ex.Message;
|
2021-11-09 13:14:31 +01:00
|
|
|
_logger.LogError(ex, "Error in {Provider}", provider.Name);
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-07 19:26:28 +02:00
|
|
|
private bool IsEnabled(TypeOptions options, ImageType type)
|
2014-10-04 20:05:24 +02:00
|
|
|
{
|
|
|
|
return options.IsEnabled(type);
|
|
|
|
}
|
|
|
|
|
2021-11-02 16:16:06 +01:00
|
|
|
private void PruneImages(BaseItem item, ItemImageInfo[] images)
|
2014-06-15 04:24:04 +02:00
|
|
|
{
|
2021-11-02 16:16:06 +01:00
|
|
|
for (var i = 0; i < images.Length; i++)
|
2014-06-15 04:24:04 +02:00
|
|
|
{
|
2021-11-01 00:16:11 +01:00
|
|
|
var image = images[i];
|
2015-12-30 03:42:17 +01:00
|
|
|
|
2021-11-01 00:16:11 +01:00
|
|
|
if (image.IsLocalFile)
|
2017-03-24 16:03:49 +01:00
|
|
|
{
|
2021-11-01 00:16:11 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
_fileSystem.DeleteFile(image.Path);
|
|
|
|
}
|
|
|
|
catch (FileNotFoundException)
|
|
|
|
{
|
|
|
|
}
|
2017-03-24 16:03:49 +01:00
|
|
|
}
|
2014-06-15 04:24:04 +02:00
|
|
|
}
|
|
|
|
|
2021-11-01 00:16:11 +01:00
|
|
|
item.RemoveImages(images);
|
2014-06-15 04:24:04 +02:00
|
|
|
}
|
|
|
|
|
2021-10-31 02:40:15 +02:00
|
|
|
/// <summary>
|
|
|
|
/// Merges a list of images into the provided item, validating existing images and replacing them or adding new images as necessary.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="item">The <see cref="BaseItem"/> to modify.</param>
|
|
|
|
/// <param name="images">The new images to place in <c>item</c>.</param>
|
|
|
|
/// <returns><c>true</c> if changes were made to the item; otherwise <c>false</c>.</returns>
|
2021-06-27 02:00:17 +02:00
|
|
|
public bool MergeImages(BaseItem item, IReadOnlyList<LocalImageInfo> images)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2021-11-01 02:38:12 +01:00
|
|
|
var changed = item.ValidateImages(new DirectoryService(_fileSystem));
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2021-05-24 00:30:41 +02:00
|
|
|
for (var i = 0; i < _singularImages.Length; i++)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2021-05-24 00:30:41 +02:00
|
|
|
var type = _singularImages[i];
|
|
|
|
var image = GetFirstLocalImageInfoByType(images, type);
|
2014-01-28 19:37:01 +01:00
|
|
|
|
|
|
|
if (image != null)
|
|
|
|
{
|
2014-02-07 21:30:41 +01:00
|
|
|
var currentImage = item.GetImageInfo(type, 0);
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2014-05-14 02:46:45 +02:00
|
|
|
if (currentImage == null)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2014-02-07 23:40:03 +01:00
|
|
|
item.SetImagePath(type, image.FileInfo);
|
2014-01-28 19:37:01 +01:00
|
|
|
changed = true;
|
|
|
|
}
|
2015-04-11 03:42:37 +02:00
|
|
|
else if (!string.Equals(currentImage.Path, image.FileInfo.FullName, StringComparison.OrdinalIgnoreCase))
|
2014-05-14 02:46:45 +02:00
|
|
|
{
|
|
|
|
item.SetImagePath(type, image.FileInfo);
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-10-30 05:52:30 +01:00
|
|
|
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;
|
2014-05-14 02:46:45 +02:00
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-14 02:46:45 +02:00
|
|
|
if (UpdateMultiImages(item, images, ImageType.Backdrop))
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2014-05-14 02:46:45 +02:00
|
|
|
changed = true;
|
|
|
|
}
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2014-05-14 02:46:45 +02:00
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2021-05-24 00:30:41 +02:00
|
|
|
private static LocalImageInfo GetFirstLocalImageInfoByType(IReadOnlyList<LocalImageInfo> 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;
|
|
|
|
}
|
|
|
|
|
2021-06-27 02:00:17 +02:00
|
|
|
private bool UpdateMultiImages(BaseItem item, IReadOnlyList<LocalImageInfo> images, ImageType type)
|
2014-05-14 02:46:45 +02:00
|
|
|
{
|
|
|
|
var changed = false;
|
|
|
|
|
2021-05-24 00:30:41 +02:00
|
|
|
var newImageFileInfos = images
|
2021-06-27 02:00:17 +02:00
|
|
|
.Where(i => i.Type == type)
|
2021-05-24 00:30:41 +02:00
|
|
|
.Select(i => i.FileInfo)
|
|
|
|
.ToList();
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2015-05-06 14:56:26 +02:00
|
|
|
if (item.AddImages(type, newImageFileInfos))
|
|
|
|
{
|
|
|
|
changed = true;
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2020-09-07 13:20:39 +02:00
|
|
|
private async Task<bool> DownloadImage(
|
|
|
|
BaseItem item,
|
2014-10-04 20:05:24 +02:00
|
|
|
IRemoteImageProvider provider,
|
|
|
|
RefreshResult result,
|
|
|
|
IEnumerable<RemoteImageInfo> images,
|
|
|
|
int minWidth,
|
|
|
|
ImageType type,
|
2014-06-15 04:24:04 +02:00
|
|
|
CancellationToken cancellationToken)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2016-01-24 05:21:31 +01:00
|
|
|
var eligibleImages = images
|
2021-11-12 15:21:46 +01:00
|
|
|
.Where(i => i.Type == type && (i.Width == null || i.Width >= minWidth))
|
2016-01-24 05:21:31 +01:00
|
|
|
.ToList();
|
|
|
|
|
2021-06-27 02:00:17 +02:00
|
|
|
if (EnableImageStub(item) && eligibleImages.Count > 0)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
2016-01-24 05:21:31 +01:00
|
|
|
SaveImageStub(item, type, eligibleImages.Select(i => i.Url));
|
2020-08-07 19:26:28 +02:00
|
|
|
result.UpdateType |= ItemUpdateType.ImageUpdate;
|
2016-01-24 05:21:31 +01:00
|
|
|
return true;
|
|
|
|
}
|
2014-02-12 04:33:30 +01:00
|
|
|
|
2016-01-24 05:21:31 +01:00
|
|
|
foreach (var image in eligibleImages)
|
|
|
|
{
|
2014-01-28 19:37:01 +01:00
|
|
|
var url = image.Url;
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2020-08-17 19:54:55 +02:00
|
|
|
using var response = await provider.GetImageResponse(url, cancellationToken).ConfigureAwait(false);
|
2021-09-21 22:47:30 +02:00
|
|
|
|
2021-09-21 23:12:38 +02:00
|
|
|
// Sometimes providers send back bad urls. Just move to the next image
|
2021-09-21 22:47:30 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-11-17 19:43:00 +01:00
|
|
|
await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2020-08-17 19:54:55 +02:00
|
|
|
await _providerManager.SaveImage(
|
|
|
|
item,
|
2020-08-17 21:22:42 +02:00
|
|
|
stream,
|
2020-08-17 19:54:55 +02:00
|
|
|
response.Content.Headers.ContentType.MediaType,
|
|
|
|
type,
|
|
|
|
null,
|
|
|
|
cancellationToken).ConfigureAwait(false);
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2020-08-07 19:26:28 +02:00
|
|
|
result.UpdateType |= ItemUpdateType.ImageUpdate;
|
2014-06-15 04:24:04 +02:00
|
|
|
return true;
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
2021-09-21 22:47:30 +02:00
|
|
|
catch (HttpRequestException)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-06-15 04:24:04 +02:00
|
|
|
|
|
|
|
return false;
|
2014-01-28 19:37:01 +01:00
|
|
|
}
|
|
|
|
|
2021-06-27 02:00:17 +02:00
|
|
|
private bool EnableImageStub(BaseItem item)
|
2015-10-17 17:05:12 +02:00
|
|
|
{
|
2016-02-26 05:09:42 +01:00
|
|
|
if (item is LiveTvProgram)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!item.IsFileProtocol)
|
2015-10-17 17:05:12 +02:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-10-31 02:40:15 +02:00
|
|
|
if (item is IItemByName and not MusicArtist)
|
2015-11-08 06:04:38 +01:00
|
|
|
{
|
|
|
|
var hasDualAccess = item as IHasDualAccess;
|
|
|
|
if (hasDualAccess == null || hasDualAccess.IsAccessedByName)
|
|
|
|
{
|
2015-11-20 18:55:38 +01:00
|
|
|
return true;
|
2015-11-08 06:04:38 +01:00
|
|
|
}
|
|
|
|
}
|
2021-07-23 02:33:19 +02:00
|
|
|
|
2020-10-19 17:28:07 +02:00
|
|
|
// We always want to use prefetched images
|
2020-05-27 19:13:41 +02:00
|
|
|
return false;
|
2015-10-17 17:05:12 +02:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private void SaveImageStub(BaseItem item, ImageType imageType, IEnumerable<string> urls)
|
2015-10-17 17:05:12 +02:00
|
|
|
{
|
|
|
|
var newIndex = item.AllowsMultipleImages(imageType) ? item.GetImages(imageType).Count() : 0;
|
|
|
|
|
2016-01-24 05:21:31 +01:00
|
|
|
SaveImageStub(item, imageType, urls, newIndex);
|
2015-11-09 19:18:37 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private void SaveImageStub(BaseItem item, ImageType imageType, IEnumerable<string> urls, int newIndex)
|
2015-11-09 19:18:37 +01:00
|
|
|
{
|
2020-09-07 13:20:39 +02:00
|
|
|
var path = string.Join('|', urls.Take(1));
|
2015-10-17 17:05:12 +02:00
|
|
|
|
2020-09-07 13:20:39 +02:00
|
|
|
item.SetImage(
|
|
|
|
new ItemImageInfo
|
|
|
|
{
|
|
|
|
Path = path,
|
|
|
|
Type = imageType
|
|
|
|
},
|
|
|
|
newIndex);
|
2015-10-17 17:05:12 +02:00
|
|
|
}
|
|
|
|
|
2021-11-02 00:31:59 +01:00
|
|
|
private async Task DownloadMultiImages(BaseItem item, ImageType imageType, ImageRefreshOptions refreshOptions, int limit, IRemoteImageProvider provider, RefreshResult result, IEnumerable<RemoteImageInfo> images, int minWidth, CancellationToken cancellationToken)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
foreach (var image in images.Where(i => i.Type == imageType))
|
|
|
|
{
|
2014-02-07 21:30:41 +01:00
|
|
|
if (item.GetImages(imageType).Count() >= limit)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-02-12 04:33:30 +01:00
|
|
|
if (image.Width.HasValue && image.Width.Value < minWidth)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-01-28 19:37:01 +01:00
|
|
|
var url = image.Url;
|
|
|
|
|
2021-06-27 02:00:17 +02:00
|
|
|
if (EnableImageStub(item))
|
2015-10-17 17:05:12 +02:00
|
|
|
{
|
2016-01-24 05:21:31 +01:00
|
|
|
SaveImageStub(item, imageType, new[] { url });
|
2020-08-07 19:26:28 +02:00
|
|
|
result.UpdateType |= ItemUpdateType.ImageUpdate;
|
2015-11-09 19:18:37 +01:00
|
|
|
continue;
|
2015-10-17 17:05:12 +02:00
|
|
|
}
|
|
|
|
|
2014-01-28 19:37:01 +01:00
|
|
|
try
|
|
|
|
{
|
2020-08-17 19:54:55 +02:00
|
|
|
using var response = await provider.GetImageResponse(url, cancellationToken).ConfigureAwait(false);
|
2014-01-28 19:37:01 +01:00
|
|
|
|
2021-09-21 23:12:38 +02:00
|
|
|
// Sometimes providers send back bad urls. Just move to the next image
|
2021-09-21 22:47:30 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2021-11-02 00:31:59 +01:00
|
|
|
// If there's already an image of the same file size, skip it unless doing a full refresh
|
|
|
|
if (response.Content.Headers.ContentLength.HasValue && !refreshOptions.IsReplacingImage(imageType))
|
2014-02-25 16:40:16 +01:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2020-08-17 19:54:55 +02:00
|
|
|
if (item.GetImages(imageType).Any(i => _fileSystem.GetFileInfo(i.Path).Length == response.Content.Headers.ContentLength.Value))
|
2014-02-25 16:40:16 +01:00
|
|
|
{
|
|
|
|
response.Content.Dispose();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (IOException ex)
|
|
|
|
{
|
2018-12-20 13:11:26 +01:00
|
|
|
_logger.LogError(ex, "Error examining images");
|
2014-02-25 16:40:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-17 19:43:00 +01:00
|
|
|
await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
|
2020-08-17 19:54:55 +02:00
|
|
|
await _providerManager.SaveImage(
|
|
|
|
item,
|
2020-08-17 21:22:42 +02:00
|
|
|
stream,
|
2020-08-17 19:54:55 +02:00
|
|
|
response.Content.Headers.ContentType.MediaType,
|
|
|
|
imageType,
|
|
|
|
null,
|
|
|
|
cancellationToken).ConfigureAwait(false);
|
2014-01-28 19:37:01 +01:00
|
|
|
result.UpdateType = result.UpdateType | ItemUpdateType.ImageUpdate;
|
|
|
|
}
|
2021-09-21 22:47:30 +02:00
|
|
|
catch (HttpRequestException)
|
2014-01-28 19:37:01 +01:00
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-12-13 14:18:25 +01:00
|
|
|
}
|