/// <summary>
/// Clears image cache
/// </summary>
/// <param name="cacheType">Cache type to invalidate</param>
public static void ClearCache(Cache.CacheType cacheType)
{
if (InternalClearCache != null)
{
InternalClearCache(cacheType);
}
}
/// <summary>
/// Invalidates cache for a specified key
/// </summary>
/// <param name="key">Key to invalidate</param>
/// <param name="cacheType">Cache type to invalidate</param>
public static void InvalidateCache(string key, Cache.CacheType cacheType)
{
if (InternalInvalidateCache != null)
{
InternalInvalidateCache(key, cacheType);
}
}
/// <summary>
/// Clears image cache
/// </summary>
/// <param name="cacheType">Cache type to invalidate</param>
public static async Task ClearCacheAsync(Cache.CacheType cacheType)
{
if (InternalClearCache != null)
{
await InternalClearCache(cacheType);
}
}
/// <summary>
/// Invalidates cache for a specified key
/// </summary>
/// <param name="key">Key to invalidate</param>
/// <param name="cacheType">Cache type to invalidate</param>
/// <param name = "removeSimilar">If set to <c>true</c> removes all image cache variants
/// (downsampling and transformations variants)</param>
public static async Task InvalidateCacheEntryAsync(string key, Cache.CacheType cacheType, bool removeSimilar = false)
{
if (InternalInvalidateCache != null)
{
await InternalInvalidateCache(key, cacheType, removeSimilar);
}
}
private static Sprite GetSprite(Cache.CacheType cacheType, string name, IconGenerator.IconType type,
int size, Color borderColor, float borderWidth, out Cache cache)
{
var bitmap = GetBitmap(cacheType, name, type, size, borderColor, borderWidth, out cache);
if (SpriteCache.ContainsKey(cache))
{
return(SpriteCache[cache]);
}
return(SpriteCache[cache] = new Sprite(TextureLoader.BitmapToTexture(bitmap))); // All done, returning sprite.
}
private static Bitmap GetBitmap(Cache.CacheType cacheType, string name, IconGenerator.IconType type,
int size, Color borderColor, float borderWidth, out Cache cache)
{
SetIconGeneratorSettings(type, size, borderColor, borderWidth);
cache = CreateCache(cacheType, name);
if (BitmapCache.ContainsKey(cache))
{
return(BitmapCache[cache]); //Bitmap has been created already, return it.
}
//Bitmap has been created yet, so lets create it and cache it.
return(BitmapCache[cache] = IconGenerator.GetIcon(name)); // All done, returning sprite.
}
/// <summary>
/// Invalidates cache for a specified image source.
/// </summary>
/// <param name="source">Image source.</param>
/// <param name="cacheType">Cache type.</param>
/// <param name = "removeSimilar">If set to <c>true</c> removes all image cache variants
/// (downsampling and transformations variants)</param>
public static async Task InvalidateCache(ImageSource source, Cache.CacheType cacheType, bool removeSimilar = false)
{
var fileImageSource = source as FileImageSource;
if (fileImageSource != null)
{
await ImageService.Instance.InvalidateCacheEntryAsync(fileImageSource.File, cacheType, removeSimilar);
}
var uriImageSource = source as UriImageSource;
if (uriImageSource != null)
{
await ImageService.Instance.InvalidateCacheEntryAsync(uriImageSource.Uri.ToString(), cacheType, removeSimilar);
}
}
private static void ClearCache(Cache.CacheType cacheType)
{
switch (cacheType)
{
case Cache.CacheType.Memory:
ImageService.InvalidateMemoryCache();
break;
case Cache.CacheType.Disk:
ImageService.InvalidateDiskCache();
break;
case Cache.CacheType.All:
ImageService.InvalidateMemoryCache();
ImageService.InvalidateDiskCache();
break;
}
}
/// <summary>
/// Invalidates cache for a specified image source.
/// </summary>
/// <param name="source">Image source.</param>
/// <param name="cacheType">Cache type.</param>
/// <param name = "removeSimilar">If set to <c>true</c> removes all image cache variants
/// (downsampling and transformations variants)</param>
public static void InvalidateCache(ImageSource source, Cache.CacheType cacheType, bool removeSimilar = false)
{
if (InternalInvalidateCache != null)
{
var fileImageSource = source as FileImageSource;
if (fileImageSource != null)
{
InternalInvalidateCache(fileImageSource.File, cacheType, removeSimilar);
}
var uriImageSource = source as UriImageSource;
if (uriImageSource != null)
{
InternalInvalidateCache(uriImageSource.Uri.ToString(), cacheType, removeSimilar);
}
}
}
private static async Task ClearCacheAsync(Cache.CacheType cacheType)
{
switch (cacheType)
{
case Cache.CacheType.Memory:
ImageService.InvalidateMemoryCache();
break;
case Cache.CacheType.Disk:
await ImageService.InvalidateDiskCacheAsync();
break;
case Cache.CacheType.All:
ImageService.InvalidateMemoryCache();
await ImageService.InvalidateDiskCacheAsync();
break;
}
}
/// <summary>
/// Invalidates cache for a specified image source.
/// </summary>
/// <param name="source">Image source.</param>
/// <param name="cacheType">Cache type.</param>
/// <param name = "removeSimilar">If set to <c>true</c> removes all image cache variants
/// (downsampling and transformations variants)</param>
public static async Task InvalidateCache(ImageSource source, Cache.CacheType cacheType, bool removeSimilar = false)
{
var fileImageSource = source as FileImageSource;
if (fileImageSource != null)
{
await ImageService.Instance.InvalidateCacheEntryAsync(fileImageSource.File, cacheType, removeSimilar).ConfigureAwait(false);
}
var uriImageSource = source as UriImageSource;
if (uriImageSource != null)
{
await ImageService.Instance.InvalidateCacheEntryAsync(uriImageSource.Uri.OriginalString, cacheType, removeSimilar).ConfigureAwait(false);
}
var embResourceSource = source as EmbeddedResourceImageSource;
if (embResourceSource != null)
{
await ImageService.Instance.InvalidateCacheEntryAsync(embResourceSource.Uri.OriginalString, cacheType, removeSimilar).ConfigureAwait(false);
}
}
private static void InvalidateCache(string key, Cache.CacheType cacheType)
{
ImageService.Invalidate(key, cacheType);
}
private static Task InvalidateCacheEntryAsync(string key, Cache.CacheType cacheType, bool removeSimilar)
{
return(ImageService.InvalidateCacheEntryAsync(key, cacheType, removeSimilar));
}
public static void InvalidateCache(string key, Cache.CacheType cacheType, bool removeSimilar = false)
{
InvalidateCacheEntryAsync(key, cacheType, removeSimilar);
}
public static void ClearCache(Cache.CacheType cacheType)
{
ClearCacheAsync(cacheType);
}
/// <summary>
/// Invalidates cache for a specified key.
/// </summary>
/// <param name="key">Image key.</param>
/// <param name="cacheType">Cache type.</param>
/// <param name = "removeSimilar">If set to <c>true</c> removes all image cache variants
/// (downsampling and transformations variants)</param>
public static Task InvalidateCache(string key, Cache.CacheType cacheType, bool removeSimilar = false)
{
return(ImageService.Instance.InvalidateCacheEntryAsync(key, cacheType, removeSimilar));
}
} // Used so constructor is called. That is all ;)
private static Cache CreateCache(Cache.CacheType cacheType, string name)
{
return(new Cache(cacheType, name, IconGenerator.Type, IconGenerator.Width, IconGenerator.BorderColor, IconGenerator.BorderWidth));
}
