// Estimate local tile cache size / space
private async void EstimateCacheSizeButton_Click(object sender, RoutedEventArgs e)
{
try
{
panelUI.IsEnabled = false;
panelExport.Visibility = Visibility.Collapsed;
panelTOC.Visibility = Visibility.Collapsed;
progress.Visibility = Visibility.Visible;
// Get current viewpoints extent from the MapView
var currentViewpoint = MyMapView.GetCurrentViewpoint(ViewpointType.BoundingGeometry);
var viewpointExtent = currentViewpoint.TargetGeometry.Extent;
_aoiOverlay.Graphics.Clear();
_aoiOverlay.Graphics.Add(new Graphic(viewpointExtent));
_aoiOverlay.IsVisible = true;
_genOptions = new GenerateTileCacheParameters()
{
Format = ExportTileCacheFormat.TilePackage,
MinScale = _onlineTiledLayer.ServiceInfo.TileInfo.Lods[(int)sliderLOD.Value].Scale,
MaxScale = _onlineTiledLayer.ServiceInfo.TileInfo.Lods[0].Scale,
GeometryFilter = GeometryEngine.Project(viewpointExtent, SpatialReferences.Wgs84)
};
var job = await _exportTilesTask.EstimateTileCacheSizeAsync(_genOptions,
(result, ex) => // Callback for when estimate operation has completed
{
if (ex == null) // Check whether operation completed with errors
{
txtExportSize.Text = string.Format("Tiles: {0} - Size (kb): {1:0}", result.TileCount, result.Size / 1024);
panelExport.Visibility = Visibility.Visible;
panelTOC.Visibility = Visibility.Collapsed;
}
else
{
MessageBox.Show(ex.Message, "Sample Error");
}
panelUI.IsEnabled = true;
progress.Visibility = Visibility.Collapsed;
},
TimeSpan.FromSeconds(1), // Check the operation every five seconds
CancellationToken.None,
new Progress <ExportTileCacheJob>((j) => // Callback for status updates
{
Debug.WriteLine(getTileCacheGenerationStatusMessage(j));
}));
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Sample Error");
panelExport.Visibility = Visibility.Visible;
panelTOC.Visibility = Visibility.Collapsed;
}
}
// Estimate local tile cache size / space
private async void EstimateCacheSizeButton_Click(object sender, RoutedEventArgs e)
{
try
{
panelUI.IsEnabled = false;
panelExport.Visibility = Visibility.Collapsed;
progress.Visibility = Visibility.Visible;
_aoiLayer.Graphics.Clear();
_aoiLayer.Graphics.Add(new Graphic(mapView.Extent));
_genOptions = new GenerateTileCacheParameters()
{
Format = ExportTileCacheFormat.TilePackage,
MinScale = _onlineTiledLayer.ServiceInfo.TileInfo.Lods[(int)sliderLOD.Value].Scale,
MaxScale = _onlineTiledLayer.ServiceInfo.TileInfo.Lods[0].Scale,
GeometryFilter = mapView.Extent
};
var job = await _exportTilesTask.EstimateTileCacheSizeAsync(_genOptions);
// Poll for the results async
while (job.Status != GPJobStatus.Cancelled && job.Status != GPJobStatus.Deleted &&
job.Status != GPJobStatus.Succeeded && job.Status != GPJobStatus.TimedOut &&
job.Status != GPJobStatus.Failed)
{
await Task.Delay(TimeSpan.FromSeconds(5));
await _exportTilesTask.CheckEstimateTileCacheSizeJobStatusAsync(job);
}
if (job.Status == GPJobStatus.Succeeded)
{
var result = await _exportTilesTask.CheckEstimateTileCacheSizeJobStatusAsync(job);
txtExportSize.Text = string.Format("Tiles: {0} - Size (kb): {1:0}", result.TileCount, result.Size / 1024);
panelExport.Visibility = Visibility.Visible;
panelTOC.Visibility = Visibility.Collapsed;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Sample Error");
}
finally
{
panelUI.IsEnabled = true;
progress.Visibility = Visibility.Collapsed;
}
}
// Estimate local tile cache size / space
private async void EstimateCacheSizeButton_Click(object sender, RoutedEventArgs e)
{
try
{
panelTOC.Visibility = Visibility.Collapsed;
panelExport.Visibility = Visibility.Collapsed;
progress.Visibility = Visibility.Visible;
// Get current viewpoints extent from the MapView
var currentViewpoint = MyMapView.GetCurrentViewpoint(ViewpointType.BoundingGeometry);
var viewpointExtent = currentViewpoint.TargetGeometry.Extent;
_aoiOverlay.Graphics.Clear();
_aoiOverlay.Graphics.Add(new Graphic(viewpointExtent));
_genOptions = new GenerateTileCacheParameters()
{
Format = ExportTileCacheFormat.TilePackage,
MinScale = _onlineTiledLayer.ServiceInfo.TileInfo.Lods[(int)sliderLOD.Value].Scale,
MaxScale = _onlineTiledLayer.ServiceInfo.TileInfo.Lods[0].Scale,
GeometryFilter = GeometryEngine.Project(viewpointExtent, SpatialReferences.Wgs84)
};
var job = await _exportTilesTask.EstimateTileCacheSizeAsync(_genOptions,
(result, ex) => // Callback for when estimate operation has completed
{
if (ex == null) // Check whether operation completed with errors
{
txtExportSize.Text = string.Format("Tiles: {0} - Size (kb): {1:0}", result.TileCount, result.Size / 1024);
panelExport.Visibility = Visibility.Visible;
panelTOC.Visibility = Visibility.Collapsed;
}
else
{
var _x = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
}
progress.Visibility = Visibility.Collapsed;
},
TimeSpan.FromSeconds(1), // Check the operation every five seconds
CancellationToken.None,
new Progress<ExportTileCacheJob>((j) => // Callback for status updates
{
Debug.WriteLine(getTileCacheGenerationStatusMessage(j));
}));
}
catch (Exception ex)
{
var _x = new MessageDialog(ex.Message, "Sample Error").ShowAsync();
}
}
// Estimate local tile cache size / space
private async void EstimateCacheSizeButton_Click(object sender, RoutedEventArgs e)
{
try
{
panelUI.IsEnabled = false;
panelExport.Visibility = Visibility.Collapsed;
progress.Visibility = Visibility.Visible;
_aoiLayer.Graphics.Clear();
_aoiLayer.Graphics.Add(new Graphic(mapView.Extent));
_genOptions = new GenerateTileCacheParameters()
{
Format = ExportTileCacheFormat.TilePackage,
MinScale = _onlineTiledLayer.ServiceInfo.TileInfo.Lods[(int)sliderLOD.Value].Scale,
MaxScale = _onlineTiledLayer.ServiceInfo.TileInfo.Lods[0].Scale,
GeometryFilter = mapView.Extent
};
var job = await _exportTilesTask.EstimateTileCacheSizeAsync(_genOptions);
// Poll for the results async
while (job.Status != GPJobStatus.Cancelled && job.Status != GPJobStatus.Deleted
&& job.Status != GPJobStatus.Succeeded && job.Status != GPJobStatus.TimedOut
&& job.Status != GPJobStatus.Failed)
{
await Task.Delay(TimeSpan.FromSeconds(5));
await _exportTilesTask.CheckEstimateTileCacheSizeJobStatusAsync(job);
}
if (job.Status == GPJobStatus.Succeeded)
{
var result = await _exportTilesTask.CheckEstimateTileCacheSizeJobStatusAsync(job);
txtExportSize.Text = string.Format("Tiles: {0} - Size (kb): {1:0}", result.TileCount, result.Size / 1024);
panelExport.Visibility = Visibility.Visible;
panelTOC.Visibility = Visibility.Collapsed;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Sample Error");
}
finally
{
panelUI.IsEnabled = true;
progress.Visibility = Visibility.Collapsed;
}
}
private async void GetTiles(object sender, RoutedEventArgs e)
{
try
{
// show the status controls
StatusPanel.Visibility = Visibility.Visible;
StatusMessagesList.Items.Add("Requesting tile cache ...");
// cancel if an earlier call was made
if (cancellationTokenSource != null)
{
cancellationTokenSource.Cancel();
}
// get a cancellation token for this task
cancellationTokenSource = new CancellationTokenSource();
var cancelToken = cancellationTokenSource.Token;
// create a new ExportTileCacheTask to generate the tiles
var exportTilesTask = new ExportTileCacheTask(new Uri(basemapUrl));
//define options for the new tiles (extent, scale levels, format)
var generateOptions = new GenerateTileCacheParameters();
generateOptions.Format = ExportTileCacheFormat.CompactCache;
generateOptions.GeometryFilter = MyMapView.Extent;
generateOptions.MinScale = 6000000.0;
generateOptions.MaxScale = 1.0;
// download the tile package to the app's local folder
var outFolder = System.AppDomain.CurrentDomain.BaseDirectory;
var downloadOptions = new DownloadTileCacheParameters(outFolder);
// overwrite the file if it already exists
downloadOptions.OverwriteExistingFiles = true;
// check generation progress every two seconds
var checkInterval = TimeSpan.FromSeconds(2);
var creationProgress = new Progress<ExportTileCacheJob>(p =>
{
StatusMessagesList.Items.Clear();
foreach (var m in p.Messages)
{
// find messages with percent complete
// "Finished:: 9 percent", e.g.
if (m.Description.Contains("Finished::"))
{
// parse out the percentage complete and update the progress bar
var numString = m.Description.Substring(m.Description.IndexOf("::") + 2, 3).Trim();
var pct = 0.0;
if (double.TryParse(numString, out pct))
{
StatusProgressBar.Value = pct;
}
}
else
{
// show other status messages in the list
StatusMessagesList.Items.Add(m.Description);
}
}
});
// show download progress
var downloadProgress = new Progress<ExportTileCacheDownloadProgress>(p =>
{
StatusProgressBar.Value = p.ProgressPercentage;
});
// generate the tiles and download them
var result = await exportTilesTask.GenerateTileCacheAndDownloadAsync(generateOptions,
downloadOptions,
checkInterval,
cancelToken,
creationProgress,
downloadProgress);
// when complete, store the path to the new local tile cache
this.localTileCachePath = result.OutputPath;
LocalTilesPathTextBlock.Text = this.localTileCachePath;
LocalTilesPathTextBlock.ToolTip = this.localTileCachePath;
// clear the working messages, report success
StatusProgressBar.Value = 100;
StatusMessagesList.Items.Clear();
StatusMessagesList.Items.Add("Local tiles created at " + this.localTileCachePath);
}
catch (Exception exp)
{
StatusMessagesList.Items.Clear();
StatusMessagesList.Items.Add("Unable to get local tiles: " + exp.Message);
}
finally
{
// reset the progress indicator
StatusProgressBar.Value = 0;
}
}
private async Task EstimateTileCacheSizeAsync()
{
if (!(CurrentEsriMapView.Map.Layers[0] is ArcGISTiledMapServiceLayer))
{
return;
}
var arcGisTiledMapServiceLayer = CurrentEsriMapView.Map.Layers[0] as ArcGISTiledMapServiceLayer;
_generateTileCacheParameters = new GenerateTileCacheParameters
{
Format = ExportTileCacheFormat.TilePackage,
MinScale = CurrentEsriMapView.MinScale,
MaxScale = CurrentEsriMapView.MaxScale,
GeometryFilter = _areaToExportGraphic.Geometry.Extent
};
Uri exportArcGisTiledMapServiceLayerServiceUri = null;
if (arcGisTiledMapServiceLayer.ServiceUri.Contains("services.arcgisonline.com"))
{
var uriBuilder = new UriBuilder(arcGisTiledMapServiceLayer.ServiceUri)
{
Scheme = "https",
Host = ExportTiledBaseMapServiceHost,
Port = -1
};
exportArcGisTiledMapServiceLayerServiceUri = uriBuilder.Uri;
}
else
{
exportArcGisTiledMapServiceLayerServiceUri = new Uri(arcGisTiledMapServiceLayer.ServiceUri);
}
_exportTileCacheTask = new ExportTileCacheTask(exportArcGisTiledMapServiceLayerServiceUri);
var exportTileCacheJobStatusProgress = new Progress<ExportTileCacheJob>();
exportTileCacheJobStatusProgress.ProgressChanged += (p, q) =>
{
if (q.Messages == null)
return;
var text = string.Format("Job Status: {0}\n\nMessages:\n=====================\n", q.Status);
foreach (GPMessage message in q.Messages)
{
text += string.Format("Message type: {0}\nMessage: {1}\n--------------------\n",
message.MessageType, message.Description);
}
};
var tcs = new TaskCompletionSource<EstimateTileCacheSizeResult>();
await _exportTileCacheTask.EstimateTileCacheSizeAsync(_generateTileCacheParameters,
(result, ex) => // Callback for when estimate operation has completed
{
if (result != null)
{
tcs.SetResult(result);
}
if (ex != null)
{
tcs.SetException(ex);
}
if (ex == null) // Check whether operation completed with errors
{
_model.SetMessageInfo(string.Format("Tiles: {0} - Size (kb): {1:0}", result.TileCount, result.Size/1024));
}
else
{
_model.SetMessageInfo(string.Format("Error: {0}", ex.Message));
}
}, TimeSpan.FromSeconds(5), CancellationToken.None, exportTileCacheJobStatusProgress);
await tcs.Task;
}
private void Reset()
{
if (_graphicsOverlay != null)
{
_graphicsOverlay.Graphics.Clear();
}
CurrentState = CreateOfflineMapState.IsReady;
_exportTileCacheTask = null;
_generateTileCacheParameters = null;
_exportMapPath = string.Empty;
_areaToExportGraphic = null;
OfflineMapName = string.Empty;
CurrentEsriMapView = null;
IsMapLoaded = false;
}
