ClemensFischer/XAML-Map-Control
1
0
Fork 0
mirror of https://github.com/ClemensFischer/XAML-Map-Control.git synced 2025-12-06 07:12:04 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Updated TileImageLoader and ImageFileCache for WinUI

Browse source
This commit is contained in:
Clemens 2021-06-28 23:35:03 +02:00
parent 9ebc88204b
commit a9475f79fe
7 changed files with 90 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
MapControl/Shared/TileImageLoader.cs
View file

@ -111,30 +111,30 @@ namespace MapControl
Interlocked.Decrement(ref taskCount);
}
private static async Task LoadTileAsync(Tile tile, TileSource tileSource, string cacheName)
private static Task LoadTileAsync(Tile tile, TileSource tileSource, string cacheName)
{
if (cacheName == null)
{
await LoadTileAsync(tile, tileSource).ConfigureAwait(false);
return LoadTileAsync(tile, tileSource);
}
else
var uri = tileSource.GetUri(tile.XIndex, tile.Y, tile.ZoomLevel);
if (uri == null)
{
var uri = tileSource.GetUri(tile.XIndex, tile.Y, tile.ZoomLevel);
if (uri != null)
{
var extension = Path.GetExtension(uri.LocalPath);
if (string.IsNullOrEmpty(extension) || extension == ".jpeg")
{
extension = ".jpg";
}
var cacheKey = string.Format("{0}/{1}/{2}/{3}{4}", cacheName, tile.ZoomLevel, tile.XIndex, tile.Y, extension);
await LoadCachedTileAsync(tile, uri, cacheKey).ConfigureAwait(false);
}
return Task.CompletedTask;
}
var extension = Path.GetExtension(uri.LocalPath);
if (string.IsNullOrEmpty(extension) || extension == ".jpeg")
{
extension = ".jpg";
}
var cacheKey = string.Format("{0}/{1}/{2}/{3}{4}", cacheName, tile.ZoomLevel, tile.XIndex, tile.Y, extension);
return LoadCachedTileAsync(tile, uri, cacheKey);
}
private static DateTime GetExpiration(TimeSpan? maxAge)

17
MapControl/UWP/ImageFileCache.UWP.cs
View file

@ -13,13 +13,17 @@ namespace MapControl.Caching
{
public class ImageFileCache : IImageCache
{
private readonly StorageFolder folder;
private readonly string folderPath;
public ImageFileCache(StorageFolder folder)
: this(folder.Path)
{
this.folder = folder ?? throw new ArgumentNullException(nameof(folder));
}
Debug.WriteLine("Created ImageFileCache in " + folder.Path);
public ImageFileCache(string path)
{
folderPath = path;
Debug.WriteLine("Created ImageFileCache in " + folderPath);
}
public async Task<ImageCacheItem> GetAsync(string key)
@ -36,6 +40,7 @@ namespace MapControl.Caching
return null;
}
var folder = await StorageFolder.GetFolderFromPathAsync(folderPath);
var item = await folder.TryGetItemAsync(path);
if (item != null && item.IsOfType(StorageItemTypes.File))
@ -68,7 +73,7 @@ namespace MapControl.Caching
try
{
var folder = this.folder;
var folder = await StorageFolder.GetFolderFromPathAsync(folderPath);
for (int i = 0; i < folders.Length - 1; i++)
{
@ -88,12 +93,12 @@ namespace MapControl.Caching
}
catch (Exception ex)
{
Debug.WriteLine("ImageFileCache: Writing {0}: {1}", Path.Combine(folder.Path, Path.Combine(folders)), ex.Message);
Debug.WriteLine("ImageFileCache: Writing {0}: {1}", Path.Combine(folderPath, Path.Combine(folders)), ex.Message);
}
}
}
private string[] GetPathElements(string key)
private static string[] GetPathElements(string key)
{
return key.Split('\\', '/', ',', ':', ';');
}

44
MapControl/UWP/Tile.UWP.cs
View file

@ -3,54 +3,20 @@
// Licensed under the Microsoft Public License (Ms-PL)
using System;
using System.Threading.Tasks;
#if WINUI
using Microsoft.System;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Media.Imaging;
#else
using Windows.UI.Core;
#if WINDOWS_UWP
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Media.Imaging;
#else
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Media.Imaging;
#endif
namespace MapControl
{
public partial class Tile
{
public async Task SetImageAsync(Func<Task<ImageSource>> loadImageFunc)
{
var tcs = new TaskCompletionSource<object>();
async void callback()
{
try
{
SetImage(await loadImageFunc());
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}
#if WINUI
if (!Image.DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, callback))
{
// should never happen, but just in case: reset Pending state and complete TaskCompletionSource
Pending = true;
tcs.SetResult(null);
}
#else
_ = Image.Dispatcher.RunAsync(CoreDispatcherPriority.Low, callback);
#endif
_ = await tcs.Task.ConfigureAwait(false); // wait until image loading in UI thread is completed
}
public void SetImage(ImageSource image, bool fadeIn = true)
{
Pending = false;

53
MapControl/UWP/TileImageLoader.UWP.cs
View file

@ -6,6 +6,13 @@ using System;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Threading.Tasks;
using Windows.Storage;
#if WINDOWS_UWP
using Windows.UI.Core;
using Windows.UI.Xaml.Media;
#else
using Microsoft.System;
using Microsoft.UI.Xaml.Media;
#endif
namespace MapControl
{
@ -45,13 +52,55 @@ namespace MapControl
if (buffer != null && buffer.Length > 0)
{
await tile.SetImageAsync(() => ImageLoader.LoadImageAsync(buffer)).ConfigureAwait(false);
await SetTileImageAsync(tile, () => ImageLoader.LoadImageAsync(buffer)).ConfigureAwait(false);
}
}
private static Task LoadTileAsync(Tile tile, TileSource tileSource)
{
return tile.SetImageAsync(() => tileSource.LoadImageAsync(tile.XIndex, tile.Y, tile.ZoomLevel));
return SetTileImageAsync(tile, () => tileSource.LoadImageAsync(tile.XIndex, tile.Y, tile.ZoomLevel));
}
#if WINDOWS_UWP
public static async Task SetTileImageAsync(Tile tile, Func<Task<ImageSource>> loadImageFunc)
{
var tcs = new TaskCompletionSource<object>();
await tile.Image.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async () =>
{
try
{
tile.SetImage(await loadImageFunc());
tcs.TrySetResult(null);
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
});
await tcs.Task.ConfigureAwait(false);
}
#else
public static Task SetTileImageAsync(Tile tile, Func<Task<ImageSource>> loadImageFunc)
{
var tcs = new TaskCompletionSource();
tile.Image.DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, async () =>
{
try
{
tile.SetImage(await loadImageFunc());
tcs.TrySetResult();
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
});
return tcs.Task;
}
#endif
}
}

1
MapControl/WPF/ImageFileCache.WPF.cs
View file

@ -38,6 +38,7 @@ namespace MapControl.Caching
}
rootDirectory = directory;
Debug.WriteLine("Created ImageFileCache in " + rootDirectory);
}
public Task Clean()

6
MapControl/WPF/Tile.WPF.cs
View file

@ -6,17 +6,11 @@ using System;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
namespace MapControl
{
public partial class Tile
{
public DispatcherOperation SetImageAsync(ImageSource image)
{
return Image.Dispatcher.InvokeAsync(() => SetImage(image));
}
public void SetImage(ImageSource image, bool fadeIn = true)
{
Pending = false;

8
MapControl/WPF/TileImageLoader.WPF.cs
View file

@ -6,11 +6,11 @@ using System;
using System.IO;
using System.Runtime.Caching;
using System.Threading.Tasks;
using System.Windows.Media;
using MapControl.Caching;
namespace MapControl
{
using Caching;
namespace Caching
{
public class ImageCacheItem
@ -58,7 +58,7 @@ namespace MapControl
{
var image = await ImageLoader.LoadImageAsync(buffer).ConfigureAwait(false);
await tile.SetImageAsync(image);
await tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(image));
}
}
@ -66,7 +66,7 @@ namespace MapControl
{
var image = await tileSource.LoadImageAsync(tile.XIndex, tile.Y, tile.ZoomLevel).ConfigureAwait(false);
await tile.SetImageAsync(image);
await tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(image));
}
private static Task<ImageCacheItem> GetCacheAsync(string cacheKey)