public WorkScheduler(Configuration configuration, IPlatformPerformance performance)
{
Configuration = configuration;
Performance = performance;
PendingTasks = new List<PendingTask>();
RunningTasks = new Dictionary<string, PendingTask>();
}
protected override void PlatformSpecificConfiguration(Config.Configuration configuration)
{
base.PlatformSpecificConfiguration(configuration);
configuration.ClearMemoryCacheOnOutOfMemory = false;
configuration.ExecuteCallbacksOnUIThread = true;
}
/// <summary>
/// Initializes FFImageLoading with a given Configuration. It allows to configure and override most of it.
/// Also forces to run disk cache cleaning routines (avoiding delay for first image loading tasks)
/// </summary>
/// <param name="configuration">Configuration.</param>
public void Initialize(Configuration configuration)
{
lock (_initializeLock)
{
_initialized = false;
if (_config != null)
{
// If DownloadCache is not updated but HttpClient is then we inform DownloadCache
if (configuration.HttpClient != null && configuration.DownloadCache == null)
{
configuration.DownloadCache = _config.DownloadCache;
configuration.DownloadCache.DownloadHttpClient = configuration.HttpClient;
}
// Redefine these if they were provided only
configuration.HttpClient = configuration.HttpClient ?? _config.HttpClient;
configuration.Scheduler = configuration.Scheduler ?? _config.Scheduler;
configuration.Logger = configuration.Logger ?? _config.Logger;
configuration.DownloadCache = configuration.DownloadCache ?? _config.DownloadCache;
// Skip configuration for maxMemoryCacheSize and diskCache. They cannot be redefined.
if (configuration.Logger != null)
configuration.Logger.Debug("Skip configuration for maxMemoryCacheSize and diskCache. They cannot be redefined.");
configuration.MaxMemoryCacheSize = _config.MaxMemoryCacheSize;
configuration.DiskCache = _config.DiskCache;
}
InitializeIfNeeded(configuration);
}
}
public SimpleDiskCache(string cachePath, Configuration configuration)
{
Configuration = configuration;
cacheFolder = null;
cacheFolderName = cachePath;
initTask = Init();
}
/// <summary>
/// Initializes FFImageLoading with a given Configuration. It allows to configure and override most of it.
/// Also forces to run disk cache cleaning routines (avoiding delay for first image loading tasks)
/// </summary>
/// <param name="configuration">Configuration.</param>
public void Initialize(Configuration configuration)
{
lock (_initializeLock)
{
_initialized = false;
if (_config != null)
{
// Redefine these if they were provided only
configuration.HttpClient = configuration.HttpClient ?? _config.HttpClient;
configuration.Scheduler = configuration.Scheduler ?? _config.Scheduler;
configuration.Logger = configuration.Logger ?? _config.Logger;
configuration.DownloadCache = configuration.DownloadCache ?? _config.DownloadCache;
configuration.DataResolverFactory = configuration.DataResolverFactory ?? _config.DataResolverFactory;
configuration.SchedulerMaxParallelTasksFactory = configuration.SchedulerMaxParallelTasksFactory ?? _config.SchedulerMaxParallelTasksFactory;
configuration.MD5Helper = configuration.MD5Helper ?? _config.MD5Helper;
// Skip configuration for maxMemoryCacheSize and diskCache. They cannot be redefined.
if (configuration.Logger != null)
configuration.Logger.Debug("Skip configuration for maxMemoryCacheSize and diskCache. They cannot be redefined.");
configuration.MaxMemoryCacheSize = _config.MaxMemoryCacheSize;
configuration.DiskCache = _config.DiskCache;
}
InitializeIfNeeded(configuration);
}
}
/// <summary>
/// Creates new cache default instance.
/// </summary>
/// <returns>The cache.</returns>
/// <param name="cacheName">Cache name.</param>
public static SimpleDiskCache CreateCache(string cacheName, Configuration configuration)
{
#if __ANDROID__
var context = new Android.Content.ContextWrapper(Android.App.Application.Context);
string tmpPath = context.CacheDir.AbsolutePath;
string cachePath = Path.Combine(tmpPath, cacheName);
#else
var documents = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string tmpPath = Path.Combine(documents, "..", "Library", "Caches");
string cachePath = Path.Combine(tmpPath, cacheName);
#endif
return new SimpleDiskCache(cachePath, configuration);
}
/// <summary>
/// Initializes a new instance of the <see cref="FFImageLoading.Cache.SimpleDiskCache"/> class.
/// </summary>
/// <param name="cachePath">Cache path.</param>
public SimpleDiskCache(string cachePath, Configuration configuration)
{
_cachePath = cachePath;
Configuration = configuration;
Logger?.Debug("SimpleDiskCache path: " + cachePath);
if (!Directory.Exists(cachePath))
Directory.CreateDirectory(cachePath);
InitializeEntries();
ThreadPool.QueueUserWorkItem(CleanCallback);
}
public virtual async Task<CacheStream> DownloadAndCacheIfNeededAsync(string url, TaskParameter parameters, Configuration configuration, CancellationToken token)
{
var allowCustomKey = !string.IsNullOrWhiteSpace(parameters.CustomCacheKey)
&& (string.IsNullOrWhiteSpace(parameters.LoadingPlaceholderPath) || parameters.LoadingPlaceholderPath != url)
&& (string.IsNullOrWhiteSpace(parameters.ErrorPlaceholderPath) || parameters.ErrorPlaceholderPath != url);
string filename = (allowCustomKey ? MD5Helper.MD5(parameters.CustomCacheKey) : MD5Helper.MD5(url))?.ToSanitizedKey();
var allowDiskCaching = AllowDiskCaching(parameters.CacheType);
var duration = parameters.CacheDuration.HasValue ? parameters.CacheDuration.Value : configuration.DiskCacheDuration;
string filePath = null;
if (allowDiskCaching)
{
var diskStream = await configuration.DiskCache.TryGetStreamAsync(filename).ConfigureAwait(false);
if (diskStream != null)
{
token.ThrowIfCancellationRequested();
filePath = await configuration.DiskCache.GetFilePathAsync(filename).ConfigureAwait(false);
return new CacheStream(diskStream, true, filePath);
}
}
token.ThrowIfCancellationRequested();
var downloadInfo = new DownloadInformation(url, parameters.CustomCacheKey, filename, allowDiskCaching, duration);
parameters.OnDownloadStarted?.Invoke(downloadInfo);
var responseBytes = await Retry.DoAsync(
async () => await DownloadAsync(url, token, configuration.HttpClient).ConfigureAwait(false),
DelayBetweenRetry,
parameters.RetryCount,
() => configuration.Logger.Debug(string.Format("Retry download: {0}", url)));
if (responseBytes == null)
throw new HttpRequestException("No Content");
if (allowDiskCaching)
{
await configuration.DiskCache.AddToSavingQueueIfNotExistsAsync(filename, responseBytes, duration).ConfigureAwait(false);
}
token.ThrowIfCancellationRequested();
filePath = await configuration.DiskCache.GetFilePathAsync(filename).ConfigureAwait(false);
token.ThrowIfCancellationRequested();
var memoryStream = new MemoryStream(responseBytes, false);
return new CacheStream(memoryStream, false, filePath);
}
public virtual IDataResolver GetResolver(string identifier, ImageSource source, TaskParameter parameters, Configuration configuration)
{
switch (source)
{
case ImageSource.ApplicationBundle:
case ImageSource.CompiledResource:
return new ResourceDataResolver();
case ImageSource.Filepath:
return new FileDataResolver();
case ImageSource.Url:
return new UrlDataResolver(configuration);
case ImageSource.Stream:
return new StreamDataResolver();
default:
throw new ArgumentException("Unknown type of ImageSource");
}
}
public static void Initialize(int? maxCacheSize = null, HttpClient httpClient = null, IWorkScheduler scheduler = null, IMiniLogger logger = null,
IDiskCache diskCache = null, IDownloadCache downloadCache = null, bool? loadWithTransparencyChannel = null, bool? fadeAnimationEnabled = null,
bool? transformPlaceholders = null, InterpolationMode? downsampleInterpolationMode = null, int httpHeadersTimeout = 15, int httpReadTimeout = 30
)
{
var cfg = new Configuration();
if (httpClient != null) cfg.HttpClient = httpClient;
if (scheduler != null) cfg.Scheduler = scheduler;
if (logger != null) cfg.Logger = logger;
if (diskCache != null) cfg.DiskCache = diskCache;
if (downloadCache != null) cfg.DownloadCache = downloadCache;
if (loadWithTransparencyChannel.HasValue) cfg.LoadWithTransparencyChannel = loadWithTransparencyChannel.Value;
if (fadeAnimationEnabled.HasValue) cfg.FadeAnimationEnabled = fadeAnimationEnabled.Value;
if (transformPlaceholders.HasValue) cfg.TransformPlaceholders = transformPlaceholders.Value;
if (downsampleInterpolationMode.HasValue) cfg.DownsampleInterpolationMode = downsampleInterpolationMode.Value;
cfg.HttpHeadersTimeout = httpHeadersTimeout;
cfg.HttpReadTimeout = httpReadTimeout;
if (maxCacheSize.HasValue) cfg.MaxCacheSize = maxCacheSize.Value;
Initialize(cfg);
}
public static void Initialize(Configuration configuration)
{
lock (_initializeLock)
{
_initialized = false;
if (Config != null)
{
// If DownloadCache is not updated but HttpClient is then we inform DownloadCache
if (configuration.HttpClient != null && configuration.DownloadCache == null)
{
configuration.DownloadCache = Config.DownloadCache;
configuration.DownloadCache.DownloadHttpClient = configuration.HttpClient;
}
// Redefine these if they were provided only
configuration.HttpClient = configuration.HttpClient ?? Config.HttpClient;
configuration.Scheduler = configuration.Scheduler ?? Config.Scheduler;
configuration.Logger = configuration.Logger ?? Config.Logger;
configuration.DownloadCache = configuration.DownloadCache ?? Config.DownloadCache;
configuration.LoadWithTransparencyChannel = configuration.LoadWithTransparencyChannel;
configuration.FadeAnimationEnabled = configuration.FadeAnimationEnabled;
configuration.TransformPlaceholders = configuration.TransformPlaceholders;
configuration.DownsampleInterpolationMode = configuration.DownsampleInterpolationMode;
// Skip configuration for maxCacheSize and diskCache. They cannot be redefined.
if (configuration.Logger != null)
configuration.Logger.Debug("Skip configuration for maxCacheSize and diskCache. They cannot be redefined.");
configuration.MaxCacheSize = Config.MaxCacheSize;
configuration.DiskCache = Config.DiskCache;
}
InitializeIfNeeded(configuration);
}
}
public DownloadCache(Configuration configuration)
{
Configuration = configuration;
}
/// <summary>
/// Creates new cache default instance.
/// </summary>
/// <returns>The cache.</returns>
/// <param name="cacheName">Cache name.</param>
public static SimpleDiskCache CreateCache(string cacheName, Configuration configuration)
{
return new SimpleDiskCache(cacheName, configuration);
}
private static Configuration GetDefaultConfiguration(Configuration userDefinedConfig)
{
var httpClient = userDefinedConfig.HttpClient ?? new HttpClient(new ModernHttpClient.NativeMessageHandler(true, false));
var logger = userDefinedConfig.Logger ?? new MiniLogger();
var scheduler = userDefinedConfig.Scheduler ?? new WorkScheduler(logger);
var diskCache = userDefinedConfig.DiskCache ?? DiskCache.CreateCache(typeof(ImageService).Name);
var downloadCache = userDefinedConfig.DownloadCache ?? new DownloadCache(httpClient, diskCache);
return new Configuration(
userDefinedConfig.MaxCacheSize,
httpClient,
scheduler,
logger,
diskCache,
downloadCache
);
}
private static void InitializeIfNeeded(int maxCacheSize = 0, HttpClient httpClient = null, IWorkScheduler scheduler = null, IMiniLogger logger = null,
IDiskCache diskCache = null, IDownloadCache downloadCache = null, bool loadWithTransparencyChannel = false, bool fadeAnimationEnabled = true,
int httpHeadersTimeout = HttpHeadersTimeout, int httpReadTimeout = HttpReadTimeout
)
{
if (_initialized)
return;
lock (_initializeLock)
{
if (_initialized)
return;
var userDefinedConfig = new Configuration(maxCacheSize, httpClient, scheduler, logger, diskCache, downloadCache, loadWithTransparencyChannel, fadeAnimationEnabled, httpHeadersTimeout, httpReadTimeout);
Config = GetDefaultConfiguration(userDefinedConfig);
_initialized = true;
}
}
private static Configuration GetDefaultConfiguration(Configuration userDefinedConfig)
{
var httpClient = userDefinedConfig.HttpClient ?? new HttpClient(new ModernHttpClient.NativeMessageHandler(true, false));
if (userDefinedConfig.HttpReadTimeout > 0)
{
httpClient.Timeout = TimeSpan.FromSeconds(userDefinedConfig.HttpReadTimeout);
}
var logger = userDefinedConfig.Logger ?? new MiniLogger();
var scheduler = userDefinedConfig.Scheduler ?? new WorkScheduler(logger);
var diskCache = userDefinedConfig.DiskCache ?? DiskCache.CreateCache(typeof(ImageService).Name);
var downloadCache = userDefinedConfig.DownloadCache ?? new DownloadCache(httpClient, diskCache);
return new Configuration(
userDefinedConfig.MaxCacheSize,
httpClient,
scheduler,
logger,
diskCache,
downloadCache,
userDefinedConfig.LoadWithTransparencyChannel,
userDefinedConfig.FadeAnimationEnabled,
userDefinedConfig.HttpHeadersTimeout,
userDefinedConfig.HttpReadTimeout
);
}
private static void InitializeIfNeeded(Configuration userDefinedConfig = null)
{
if (_initialized)
return;
lock (_initializeLock)
{
if (_initialized)
return;
if (userDefinedConfig == null)
userDefinedConfig = new Configuration();
var httpClient = userDefinedConfig.HttpClient ?? new HttpClient();
if (userDefinedConfig.HttpReadTimeout > 0)
{
httpClient.Timeout = TimeSpan.FromSeconds(userDefinedConfig.HttpReadTimeout);
}
var logger = userDefinedConfig.Logger ?? new MiniLogger();
var scheduler = userDefinedConfig.Scheduler ?? new WorkScheduler(logger);
var diskCache = userDefinedConfig.DiskCache ?? DiskCache.CreateCache(typeof(ImageService).Name);
var downloadCache = userDefinedConfig.DownloadCache ?? new DownloadCache(httpClient, diskCache);
userDefinedConfig.HttpClient = httpClient;
userDefinedConfig.Scheduler = scheduler;
userDefinedConfig.Logger = logger;
userDefinedConfig.DiskCache = diskCache;
userDefinedConfig.DownloadCache = downloadCache;
Config = userDefinedConfig;
_initialized = true;
}
}
private void InitializeIfNeeded(Configuration userDefinedConfig = null)
{
if (_initialized)
return;
lock (_initializeLock)
{
if (_initialized)
return;
if (userDefinedConfig == null)
userDefinedConfig = new Configuration();
var logger = new MiniLoggerWrapper(userDefinedConfig.Logger ?? new MiniLogger(), userDefinedConfig.VerboseLogging);
userDefinedConfig.Logger = logger;
var md5Helper = userDefinedConfig.MD5Helper ?? new MD5Helper();
userDefinedConfig.MD5Helper = md5Helper;
var httpClient = userDefinedConfig.HttpClient ?? new HttpClient();
if (userDefinedConfig.HttpReadTimeout > 0)
{
httpClient.Timeout = TimeSpan.FromSeconds(userDefinedConfig.HttpReadTimeout);
}
userDefinedConfig.HttpClient = httpClient;
var scheduler = userDefinedConfig.Scheduler ?? new WorkScheduler(userDefinedConfig, new PlatformPerformance());
userDefinedConfig.Scheduler = scheduler;
if (string.IsNullOrWhiteSpace(userDefinedConfig.DiskCachePath))
{
var diskCache = userDefinedConfig.DiskCache ?? SimpleDiskCache.CreateCache("FFSimpleDiskCache", userDefinedConfig);
userDefinedConfig.DiskCache = diskCache;
}
else
{
var diskCache = userDefinedConfig.DiskCache ?? new SimpleDiskCache(userDefinedConfig.DiskCachePath, userDefinedConfig);
userDefinedConfig.DiskCache = diskCache;
}
var downloadCache = userDefinedConfig.DownloadCache ?? new DownloadCache(userDefinedConfig);
userDefinedConfig.DownloadCache = downloadCache;
Config = userDefinedConfig;
_initialized = true;
}
}
private static void InitializeIfNeeded(int maxCacheSize = 0, HttpClient httpClient = null, IWorkScheduler scheduler = null, IMiniLogger logger = null,
IDiskCache diskCache = null, IDownloadCache downloadCache = null)
{
if (_initialized)
return;
lock (_initializeLock)
{
if (_initialized)
return;
var userDefinedConfig = new Configuration(maxCacheSize, httpClient, scheduler, logger, diskCache, downloadCache);
Config = GetDefaultConfiguration(userDefinedConfig);
_initialized = true;
}
}
public UrlDataResolver(Configuration configuration)
{
Configuration = configuration;
}
