Version 4.10.0: Improved ImageLoader and MBTiles.

MBTiles/Shared/MBTileData.cs

@@ -0,0 +1,140 @@
+// XAML Map Control - https://github.com/ClemensFischer/XAML-Map-Control
+// © 2018 Clemens Fischer
+// Licensed under the Microsoft Public License (Ms-PL)
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading.Tasks;
+#if WINDOWS_UWP
+using SQLiteCommand = Microsoft.Data.Sqlite.SqliteCommand;
+using SQLiteConnection = Microsoft.Data.Sqlite.SqliteConnection;
+#else
+using System.Data.SQLite;
+#endif
+
+namespace MapControl
+{
+    public class MBTileData : IDisposable
+    {
+        private readonly SQLiteConnection connection;
+
+        public MBTileData(string file)
+        {
+            connection = new SQLiteConnection("Data Source=" + file);
+        }
+
+        public Task OpenAsync()
+        {
+            return connection.OpenAsync();
+        }
+
+        public void Close()
+        {
+            connection.Close();
+        }
+
+        public void Dispose()
+        {
+            Close();
+        }
+
+        public async Task<IDictionary<string, string>> ReadMetadataAsync()
+        {
+            var metadata = new Dictionary<string, string>();
+
+            try
+            {
+                using (var command = new SQLiteCommand("select * from metadata", connection))
+                {
+                    var reader = await command.ExecuteReaderAsync();
+
+                    while (await reader.ReadAsync())
+                    {
+                        metadata[(string)reader["name"]] = (string)reader["value"];
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine("MBTileData: " + ex.Message);
+            }
+
+            return metadata;
+        }
+
+        public async Task WriteMetadataAsync(IDictionary<string, object> metadata)
+        {
+            try
+            {
+                using (var command = new SQLiteCommand("create table if not exists metadata (name string, value string)", connection))
+                {
+                    await command.ExecuteNonQueryAsync();
+                }
+
+                foreach (var keyValue in metadata)
+                {
+                    using (var command = new SQLiteCommand("insert or replace into metadata (name, value) values (@n, @v)", connection))
+                    {
+                        command.Parameters.AddWithValue("@n", keyValue.Key);
+                        command.Parameters.AddWithValue("@v", keyValue.Value.ToString());
+
+                        await command.ExecuteNonQueryAsync();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine("MBTileData: " + ex.Message);
+            }
+        }
+
+        public async Task<byte[]> ReadImageBufferAsync(int x, int y, int zoomLevel)
+        {
+            byte[] imageBuffer = null;
+
+            try
+            {
+                using (var command = new SQLiteCommand("select tile_data from tiles where zoom_level=@z and tile_column=@x and tile_row=@y", connection))
+                {
+                    command.Parameters.AddWithValue("@z", zoomLevel);
+                    command.Parameters.AddWithValue("@x", x);
+                    command.Parameters.AddWithValue("@y", (1 << zoomLevel) - y - 1);
+
+                    imageBuffer = await command.ExecuteScalarAsync() as byte[];
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine("MBTileData: {0}/{1}/{2}: {3}", zoomLevel, x, y, ex.Message);
+            }
+
+            return imageBuffer;
+        }
+
+        public async Task WriteImageBufferAsync(int x, int y, int zoomLevel, byte[] imageBuffer)
+        {
+            try
+            {
+                using (var command = new SQLiteCommand("create table if not exists tiles (zoom_level integer, tile_column integer, tile_row integer, tile_data blob)", connection))
+                {
+                    await command.ExecuteNonQueryAsync();
+                }
+
+                using (var command = new SQLiteCommand("insert or replace into tiles (zoom_level, tile_column, tile_row, tile_data) values (@z, @x, @y, @b)", connection))
+                {
+                    command.Parameters.AddWithValue("@z", zoomLevel);
+                    command.Parameters.AddWithValue("@x", x);
+                    command.Parameters.AddWithValue("@y", (1 << zoomLevel) - y - 1);
+                    command.Parameters.AddWithValue("@b", imageBuffer);
+
+                    await command.ExecuteNonQueryAsync();
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine("MBTileData: {0}/{1}/{2}: {3}", zoomLevel, x, y, ex.Message);
+            }
+        }
+    }
+}

MBTiles/Shared/MBTileLayer.cs

@@ -2,6 +2,7 @@
 // © 2018 Clemens Fischer
 // Licensed under the Microsoft Public License (Ms-PL)
 
+using System.Threading.Tasks;
 #if WINDOWS_UWP
 using Windows.UI.Xaml;
 #else
@@ -14,7 +15,7 @@ namespace MapControl
     {
         public static readonly DependencyProperty FileProperty = DependencyProperty.Register(
             nameof(File), typeof(string), typeof(MBTileLayer),
-            new PropertyMetadata(null, (o, e) => ((MBTileLayer)o).FilePropertyChanged((string)e.NewValue)));
+            new PropertyMetadata(null, async (o, e) => await ((MBTileLayer)o).FilePropertyChanged((string)e.NewValue)));
 
         public MBTileLayer()
             : this(new TileImageLoader())
@@ -32,67 +33,67 @@ namespace MapControl
             set { SetValue(FileProperty, value); }
         }
 
-        private void FilePropertyChanged(string file)
+        private async Task FilePropertyChanged(string file)
         {
-            MBTileSource ts;
+            var mbTileSource = TileSource as MBTileSource;
+
+            if (mbTileSource != null)
+            {
+                if (file == null)
+                {
+                    ClearValue(TileSourceProperty);
+
+                    if (mbTileSource.Name != null)
+                    {
+                        ClearValue(SourceNameProperty);
+                    }
+
+                    if (mbTileSource.Description != null)
+                    {
+                        ClearValue(DescriptionProperty);
+                    }
+
+                    if (mbTileSource.MinZoom.HasValue)
+                    {
+                        ClearValue(MinZoomLevelProperty);
+                    }
+
+                    if (mbTileSource.MaxZoom.HasValue)
+                    {
+                        ClearValue(MaxZoomLevelProperty);
+                    }
+                }
+
+                mbTileSource.Dispose();
+            }
 
             if (file != null)
             {
-                ts = new MBTileSource(file);
+                mbTileSource = new MBTileSource(file);
 
-                if (ts.Metadata.ContainsKey("name"))
+                await mbTileSource.Initialize();
+
+                if (mbTileSource.Name != null)
                 {
-                    SourceName = ts.Metadata["name"];
+                    SourceName = mbTileSource.Name;
                 }
 
-                if (ts.Metadata.ContainsKey("description"))
+                if (mbTileSource.Description != null)
                 {
-                    Description = ts.Metadata["description"];
+                    Description = mbTileSource.Description;
                 }
 
-                if (ts.Metadata.ContainsKey("minzoom"))
+                if (mbTileSource.MinZoom.HasValue)
                 {
-                    int minZoom;
-                    if (int.TryParse(ts.Metadata["minzoom"], out minZoom))
-                    {
-                        MinZoomLevel = minZoom;
-                    }
+                    MinZoomLevel = mbTileSource.MinZoom.Value;
                 }
 
-                if (ts.Metadata.ContainsKey("maxzoom"))
+                if (mbTileSource.MaxZoom.HasValue)
                 {
-                    int maxZoom;
-                    if (int.TryParse(ts.Metadata["maxzoom"], out maxZoom))
-                    {
-                        MaxZoomLevel = maxZoom;
-                    }
+                    MaxZoomLevel = mbTileSource.MaxZoom.Value;
                 }
 
-                TileSource = ts;
-            }
-            else if ((ts = TileSource as MBTileSource) != null)
-            {
-                ClearValue(TileSourceProperty);
-
-                if (ts.Metadata.ContainsKey("name"))
-                {
-                    ClearValue(SourceNameProperty);
-                }
-
-                if (ts.Metadata.ContainsKey("description"))
-                {
-                    ClearValue(DescriptionProperty);
-                }
-
-                if (ts.Metadata.ContainsKey("minzoom"))
-                {
-                    ClearValue(MinZoomLevelProperty);
-                }
-
-                if (ts.Metadata.ContainsKey("maxzoom"))
-                {
-                    ClearValue(MaxZoomLevelProperty);
-                }
+                TileSource = mbTileSource;
             }
         }
     }

MBTiles/Shared/MBTileSource.cs

@@ -0,0 +1,75 @@
+// XAML Map Control - https://github.com/ClemensFischer/XAML-Map-Control
+// © 2018 Clemens Fischer
+// Licensed under the Microsoft Public License (Ms-PL)
+
+using System;
+using System.Threading.Tasks;
+#if WINDOWS_UWP
+using Windows.UI.Xaml.Media;
+#else
+using System.Windows.Media;
+#endif
+
+namespace MapControl
+{
+    public class MBTileSource : TileSource, IDisposable
+    {
+        private readonly MBTileData tileData;
+
+        public string Name { get; private set; }
+        public string Description { get; private set; }
+        public int? MinZoom { get; private set; }
+        public int? MaxZoom { get; private set; }
+
+        public MBTileSource(string file)
+        {
+            tileData = new MBTileData(file);
+        }
+
+        public async Task Initialize()
+        {
+            await tileData.OpenAsync();
+
+            var metadata = await tileData.ReadMetadataAsync();
+
+            string name;
+            string description;
+            string minzoom;
+            string maxzoom;
+            int minZoom;
+            int maxZoom;
+
+            if (metadata.TryGetValue("name", out name))
+            {
+                Name = name;
+            }
+
+            if (metadata.TryGetValue("description", out description))
+            {
+                Description = description;
+            }
+
+            if (metadata.TryGetValue("minzoom", out minzoom) && int.TryParse(minzoom, out minZoom))
+            {
+                MinZoom = minZoom;
+            }
+
+            if (metadata.TryGetValue("maxzoom", out maxzoom) && int.TryParse(maxzoom, out maxZoom))
+            {
+                MaxZoom = maxZoom;
+            }
+        }
+
+        public void Dispose()
+        {
+            tileData.Dispose();
+        }
+
+        public override async Task<ImageSource> LoadImageAsync(int x, int y, int zoomLevel)
+        {
+            var buffer = await tileData.ReadImageBufferAsync(x, y, zoomLevel);
+
+            return buffer != null ? await ImageLoader.CreateImageSourceAsync(buffer) : null;
+        }
+    }
+}