private async Task <bool> LoadImageFromStream(Tile tile, BitmapSource image, IRandomAccessStream stream)
{
var completion = new TaskCompletionSource <bool>();
var action = image.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
async() =>
{
try
{
await image.SetSourceAsync(stream);
tile.SetImage(image, true, false);
completion.SetResult(true);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
tile.SetImage(null);
completion.SetResult(false);
}
});
return(await completion.Task);
}
private static async Task LoadCachedTileAsync(Tile tile, Uri uri, string cacheKey)
{
var cacheItem = await GetCacheAsync(cacheKey).ConfigureAwait(false);
var buffer = cacheItem?.Buffer;
if (cacheItem == null || cacheItem.Expiration < DateTime.UtcNow)
{
var response = await ImageLoader.GetHttpResponseAsync(uri).ConfigureAwait(false);
if (response != null) // download succeeded
{
buffer = response.Buffer; // may be null or empty when no tile available, but still be cached
await SetCacheAsync(cacheKey, buffer, GetExpiration(response.MaxAge)).ConfigureAwait(false);
}
}
if (buffer != null && buffer.Length > 0)
{
var image = await ImageLoader.LoadImageAsync(buffer).ConfigureAwait(false);
await tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(image));
}
}
private async Task LoadTileImageAsync(Tile tile, IBuffer buffer)
{
var tcs = new TaskCompletionSource <object>();
using (var stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(buffer);
stream.Seek(0);
await tile.Image.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async() =>
{
try
{
tile.SetImage(await ImageLoader.LoadImageAsync(stream));
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
}
await tcs.Task;
}
private static async Task LoadCachedTile(Tile tile, Uri uri, string cacheKey)
{
var cacheItem = Cache.Get(cacheKey) as Tuple <byte[], DateTime>;
var buffer = cacheItem?.Item1;
if (cacheItem == null || cacheItem.Item2 < DateTime.UtcNow)
{
var response = await ImageLoader.GetHttpResponseAsync(uri).ConfigureAwait(false);
if (response != null) // download succeeded
{
buffer = response.Buffer; // may be null or empty when no tile available, but still be cached
cacheItem = Tuple.Create(buffer, GetExpiration(response.MaxAge));
Cache.Set(cacheKey, cacheItem, new CacheItemPolicy {
AbsoluteExpiration = cacheItem.Item2
});
}
}
//else System.Diagnostics.Debug.WriteLine($"Cached: {cacheKey}");
if (buffer != null && buffer.Length > 0)
{
var image = await ImageLoader.LoadImageAsync(buffer).ConfigureAwait(false);
await tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(image));
}
}
private static Task SetTileImage(Tile tile, Func <Task <ImageSource> > loadImageFunc)
{
var tcs = new TaskCompletionSource();
async void callback()
{
try
{
tile.SetImage(await loadImageFunc());
tcs.TrySetResult();
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
}
if (!tile.Image.DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, callback))
{
tile.Pending = true;
tcs.TrySetResult();
}
return(tcs.Task);
}
private async Task SetTileImageAsync(Tile tile, IBuffer buffer)
{
var tcs = new TaskCompletionSource <object>();
using (var stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(buffer);
await stream.FlushAsync(); // necessary?
stream.Seek(0);
await tile.Image.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
try
{
var bitmapImage = new BitmapImage();
await bitmapImage.SetSourceAsync(stream);
tile.SetImage(bitmapImage);
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
}
await tcs.Task;
}
private static async Task SetTileImageAsync(Tile tile, Func <Task <ImageSource> > loadImageFunc)
{
var tcs = new TaskCompletionSource <object>();
await tile.Image.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async() =>
{
try
{
var image = await loadImageFunc();
if (image != null)
{
tile.SetImage(image);
}
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
await tcs.Task.ConfigureAwait(false);
}
private void UpdateTiles()
{
var newTiles = new List <Tile>();
if (parentMap != null && TileGrid != null && TileSource != null)
{
var maxZoomLevel = Math.Min(TileGrid.ZoomLevel, MaxZoomLevel);
var minZoomLevel = MinZoomLevel;
if (minZoomLevel < maxZoomLevel && parentMap.MapLayer != this)
{
minZoomLevel = maxZoomLevel; // do not load lower level tiles if this is note a "base" layer
}
for (var z = minZoomLevel; z <= maxZoomLevel; z++)
{
var tileSize = 1 << (TileGrid.ZoomLevel - z);
var x1 = (int)Math.Floor((double)TileGrid.XMin / tileSize); // may be negative
var x2 = TileGrid.XMax / tileSize;
var y1 = Math.Max(TileGrid.YMin / tileSize, 0);
var y2 = Math.Min(TileGrid.YMax / tileSize, (1 << z) - 1);
for (var y = y1; y <= y2; y++)
{
for (var x = x1; x <= x2; x++)
{
var tile = Tiles.FirstOrDefault(t => t.ZoomLevel == z && t.X == x && t.Y == y);
if (tile == null)
{
tile = new Tile(z, x, y);
var equivalentTile = Tiles.FirstOrDefault(
t => t.ZoomLevel == z && t.XIndex == tile.XIndex && t.Y == y && t.Image.Source != null);
if (equivalentTile != null)
{
tile.SetImage(equivalentTile.Image.Source, false); // no fade-in animation
}
}
newTiles.Add(tile);
}
}
}
}
Tiles = newTiles;
Children.Clear();
foreach (var tile in Tiles)
{
Children.Add(tile.Image);
}
TileImageLoader.LoadTilesAsync(this);
}
private void SetTiles()
{
int maxZoomLevel;
if (TileSource == null ||
TileMatrix == null ||
(maxZoomLevel = Math.Min(TileMatrix.ZoomLevel, MaxZoomLevel)) < MinZoomLevel)
{
Tiles.Clear();
}
else
{
var newTiles = new List <Tile>();
var minZoomLevel = maxZoomLevel;
if (this == ParentMap.MapLayer) // load background tiles
{
minZoomLevel = Math.Max(TileMatrix.ZoomLevel - MaxBackgroundLevels, MinZoomLevel);
}
var oldTiles = Tiles.Where(t => t.ZoomLevel >= minZoomLevel && t.ZoomLevel <= maxZoomLevel).ToList();
Tiles.Clear();
for (var z = minZoomLevel; z <= maxZoomLevel; z++)
{
var tileSize = 1 << (TileMatrix.ZoomLevel - z);
var x1 = (int)Math.Floor((double)TileMatrix.XMin / tileSize); // may be negative
var x2 = TileMatrix.XMax / tileSize;
var y1 = Math.Max(TileMatrix.YMin / tileSize, 0);
var y2 = Math.Min(TileMatrix.YMax / tileSize, (1 << z) - 1);
for (var y = y1; y <= y2; y++)
{
for (var x = x1; x <= x2; x++)
{
var tile = oldTiles.FirstOrDefault(t => t.ZoomLevel == z && t.X == x && t.Y == y);
if (tile == null)
{
tile = new Tile(z, x, y);
var equivalentTile = oldTiles.FirstOrDefault(
t => t.ZoomLevel == z && t.XIndex == tile.XIndex && t.Y == y && !t.Pending);
if (equivalentTile != null)
{
tile.SetImage(equivalentTile.Image.Source, false); // no fade-in animation
}
}
Tiles.Add(tile);
}
}
}
}
}
private void UpdateTiles()
{
var newTiles = new List <Tile>();
if (parentMap != null && TileGrid != null && TileSource != null)
{
var maxZoomLevel = Math.Min(TileGrid.ZoomLevel, MaxZoomLevel);
var minZoomLevel = parentMap.MapLayer == this ? MinZoomLevel : maxZoomLevel; // load background tiles only if this is the base layer
for (var z = minZoomLevel; z <= maxZoomLevel; z++)
{
var tileSize = 1 << (TileGrid.ZoomLevel - z);
var x1 = (int)Math.Floor((double)TileGrid.XMin / tileSize); // may be negative
var x2 = TileGrid.XMax / tileSize;
var y1 = Math.Max(TileGrid.YMin / tileSize, 0);
var y2 = Math.Min(TileGrid.YMax / tileSize, (1 << z) - 1);
for (var y = y1; y <= y2; y++)
{
for (var x = x1; x <= x2; x++)
{
var tile = Tiles.FirstOrDefault(t => t.ZoomLevel == z && t.X == x && t.Y == y);
if (tile == null)
{
tile = new Tile(z, x, y);
var equivalentTile = Tiles.FirstOrDefault(
t => t.ZoomLevel == z && t.XIndex == tile.XIndex && t.Y == y && t.Image.Source != null);
if (equivalentTile != null)
{
tile.SetImage(equivalentTile.Image.Source, false); // do not animate to avoid flicker when crossing 180° longitude
}
}
newTiles.Add(tile);
}
}
}
}
Tiles = newTiles;
Children.Clear();
foreach (var tile in Tiles)
{
Children.Add(tile.Image);
}
var task = TileImageLoader.LoadTilesAsync(this);
}
protected void SelectTiles()
{
var newTiles = new List <Tile>();
if (TileGrid != null && parentMap != null && TileSource != null)
{
var maxZoomLevel = Math.Min(TileGrid.ZoomLevel, MaxZoomLevel);
var minZoomLevel = MinZoomLevel;
if (minZoomLevel < maxZoomLevel && this != parentMap.TileLayers.FirstOrDefault())
{
// do not load background tiles if this is not the base layer
minZoomLevel = maxZoomLevel;
}
for (var z = minZoomLevel; z <= maxZoomLevel; z++)
{
var tileSize = 1 << (TileGrid.ZoomLevel - z);
var x1 = (int)Math.Floor((double)TileGrid.XMin / tileSize); // may be negative
var x2 = TileGrid.XMax / tileSize;
var y1 = Math.Max(TileGrid.YMin / tileSize, 0);
var y2 = Math.Min(TileGrid.YMax / tileSize, (1 << z) - 1);
for (var y = y1; y <= y2; y++)
{
for (var x = x1; x <= x2; x++)
{
var tile = Tiles.FirstOrDefault(t => t.ZoomLevel == z && t.X == x && t.Y == y);
if (tile == null)
{
tile = new Tile(z, x, y);
var equivalentTile = Tiles.FirstOrDefault(
t => t.ZoomLevel == z && t.XIndex == tile.XIndex && t.Y == y && t.Image.Source != null);
if (equivalentTile != null)
{
// do not animate to avoid flicker when crossing 180°
tile.SetImage(equivalentTile.Image.Source, false);
}
}
newTiles.Add(tile);
}
}
}
}
Tiles = newTiles;
}
private async Task <bool> LoadImageFromHttpResponse(HttpResponseMessage response, Tile tile, string cacheKey)
{
string tileInfo;
if (response.Headers.TryGetValue("X-VE-Tile-Info", out tileInfo) && tileInfo == "no-tile") // set by Bing Maps
{
tile.SetImage(null);
return(true);
}
using (var stream = new InMemoryRandomAccessStream())
{
using (var content = response.Content)
{
await content.WriteToStreamAsync(stream);
}
await stream.FlushAsync();
stream.Seek(0);
var loaded = await LoadImageFromStream(tile, stream);
if (loaded && cacheKey != null)
{
var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size);
stream.Seek(0);
await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None);
var expiration = DefaultCacheExpiration;
if (response.Headers.CacheControl.MaxAge.HasValue)
{
expiration = response.Headers.CacheControl.MaxAge.Value;
if (expiration < MinimumCacheExpiration)
{
expiration = MinimumCacheExpiration;
}
}
await Cache.SetAsync(cacheKey, buffer, DateTime.UtcNow.Add(expiration));
}
return(loaded);
}
}
private async Task LoadTileImageAsync(TileSource tileSource, Tile tile)
{
tile.Pending = false;
try
{
var imageSource = await tileSource.LoadImageAsync(tile.XIndex, tile.Y, tile.ZoomLevel);
if (imageSource != null)
{
tile.SetImage(imageSource);
}
}
catch (Exception ex)
{
Debug.WriteLine("TileImageLoader: {0}/{1}/{2}: {3}", tile.ZoomLevel, tile.XIndex, tile.Y, ex.Message);
}
}
private async Task LoadTileImageAsync(Tile tile, TileSource tileSource)
{
var tcs = new TaskCompletionSource <object>();
await tile.Image.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async() =>
{
try
{
tile.SetImage(await tileSource.LoadImageAsync(tile.XIndex, tile.Y, tile.ZoomLevel));
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
await tcs.Task;
}
private static async Task SetTileImageAsync(Tile tile, Func <Task <ImageSource> > loadImage)
{
var tcs = new TaskCompletionSource <object>();
await tile.Image.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async() =>
{
try
{
tile.SetImage(await loadImage());
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
await tcs.Task.ConfigureAwait(false); // wait until image loading in the UI thread is completed
}
private static async Task SetTileImage(Tile tile, Func <Task <ImageSource> > loadImageFunc)
{
var tcs = new TaskCompletionSource <object>();
async void callback()
{
try
{
tile.SetImage(await loadImageFunc());
tcs.TrySetResult(null);
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
}
await tile.Image.Dispatcher.RunAsync(CoreDispatcherPriority.Low, callback);
await tcs.Task.ConfigureAwait(false);
}
private async Task<bool> LoadImageFromStream(Tile tile, BitmapSource image, IRandomAccessStream stream)
{
var completion = new TaskCompletionSource<bool>();
var action = image.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
async () =>
{
try
{
await image.SetSourceAsync(stream);
tile.SetImage(image, true, false);
completion.SetResult(true);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
tile.SetImage(null);
completion.SetResult(false);
}
});
return await completion.Task;
}
private async Task SetTileImageAsync(Tile tile, MemoryStream stream)
{
var imageSource = BitmapFrame.Create(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
await tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(imageSource));
}
private static async Task LoadTileAsync(Tile tile, TileSource tileSource)
{
var image = await tileSource.LoadImageAsync(tile.XIndex, tile.Y, tile.ZoomLevel).ConfigureAwait(false);
await tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(image));
}
protected void SelectTiles()
{
var newTiles = new List<Tile>();
if (TileZoomLevel >= 0 && parentMap != null && TileSource != null)
{
var maxZoomLevel = Math.Min(TileZoomLevel, MaxZoomLevel);
var minZoomLevel = MinZoomLevel;
if (minZoomLevel < maxZoomLevel && this != parentMap.TileLayers.FirstOrDefault())
{
// do not load background tiles if this is not the base layer
minZoomLevel = maxZoomLevel;
}
for (var z = minZoomLevel; z <= maxZoomLevel; z++)
{
var tileSize = 1 << (TileZoomLevel - z);
var x1 = (int)Math.Floor((double)TileRect.X / tileSize); // may be negative
var x2 = (TileRect.X + TileRect.Width - 1) / tileSize;
var y1 = Math.Max(TileRect.Y / tileSize, 0);
var y2 = Math.Min((TileRect.Y + TileRect.Height - 1) / tileSize, (1 << z) - 1);
for (var y = y1; y <= y2; y++)
{
for (var x = x1; x <= x2; x++)
{
var tile = Tiles.FirstOrDefault(t => t.ZoomLevel == z && t.X == x && t.Y == y);
if (tile == null)
{
tile = new Tile(z, x, y);
var equivalentTile = Tiles.FirstOrDefault(
t => t.ZoomLevel == z && t.XIndex == tile.XIndex && t.Y == y && t.Image.Source != null);
if (equivalentTile != null)
{
// do not animate to avoid flicker when crossing 180°
tile.SetImage(equivalentTile.Image.Source, false);
}
}
newTiles.Add(tile);
}
}
}
}
Tiles = newTiles;
}
private static void SetTileImageAsync(Tile tile, ImageSource image)
{
tile.Image.Dispatcher.InvokeAsync(() => tile.SetImage(image));
}
private void UpdateTiles()
{
var newTiles = new List <Tile>();
if (ParentMap != null && TileMatrix != null && TileSource != null)
{
var maxZoomLevel = Math.Min(TileMatrix.ZoomLevel, MaxZoomLevel);
if (maxZoomLevel >= MinZoomLevel)
{
var minZoomLevel = maxZoomLevel;
if (this == ParentMap.MapLayer) // load background tiles
{
minZoomLevel = Math.Max(TileMatrix.ZoomLevel - MaxBackgroundLevels, MinZoomLevel);
}
for (var z = minZoomLevel; z <= maxZoomLevel; z++)
{
var tileSize = 1 << (TileMatrix.ZoomLevel - z);
var x1 = (int)Math.Floor((double)TileMatrix.XMin / tileSize); // may be negative
var x2 = TileMatrix.XMax / tileSize;
var y1 = Math.Max(TileMatrix.YMin / tileSize, 0);
var y2 = Math.Min(TileMatrix.YMax / tileSize, (1 << z) - 1);
for (var y = y1; y <= y2; y++)
{
for (var x = x1; x <= x2; x++)
{
var tile = Tiles.FirstOrDefault(t => t.ZoomLevel == z && t.X == x && t.Y == y);
if (tile == null)
{
tile = new Tile(z, x, y);
var equivalentTile = Tiles.FirstOrDefault(
t => t.ZoomLevel == z && t.XIndex == tile.XIndex && t.Y == y && t.Image.Source != null);
if (equivalentTile != null)
{
tile.SetImage(equivalentTile.Image.Source, false); // no fade-in animation
}
}
newTiles.Add(tile);
}
}
}
}
}
Tiles = newTiles;
Children.Clear();
foreach (var tile in Tiles)
{
Children.Add(tile.Image);
}
TileImageLoader.LoadTilesAsync(Tiles, TileSource, SourceName);
}
