// Load the online basemap and dependent UI
private async void MyMapView_Loaded(object sender, RoutedEventArgs e)
{
await InitializeOnlineBasemap();
_aoiOverlay = new GraphicsOverlay() { Renderer = LayoutRoot.Resources["AOIRenderer"] as Renderer };
MyMapView.GraphicsOverlays.Add(_aoiOverlay);
if (_onlineTiledLayer.ServiceInfo != null)
{
sliderLOD.Minimum = 0;
sliderLOD.Maximum = _onlineTiledLayer.ServiceInfo.TileInfo.Lods.Count - 1;
sliderLOD.Value = sliderLOD.Maximum;
}
_exportTilesTask = new ExportTileCacheTask(new Uri(_onlineTiledLayer.ServiceUri));
}
// Load the online basemap and dependent UI
private async void mapView_Loaded(object sender, RoutedEventArgs e)
{
await InitializeOnlineBasemap();
_aoiLayer = new GraphicsLayer() { ID = AOI_LAYER_ID, Renderer = layoutGrid.Resources["AOIRenderer"] as Renderer };
mapView.Map.Layers.Add(_aoiLayer);
if (_onlineTiledLayer.ServiceInfo != null)
{
sliderLOD.Minimum = 0;
sliderLOD.Maximum = _onlineTiledLayer.ServiceInfo.TileInfo.Lods.Count - 1;
sliderLOD.Value = (int)(sliderLOD.Maximum / 2);
}
_exportTilesTask = new ExportTileCacheTask(new Uri(_onlineTiledLayer.ServiceUri));
}
/// <summary>
///
/// </summary>
/// <param name="map"></param>
/// <param name="viewpoint"></param>
/// <returns></returns>
public async Task <ValidateReplicaResult> ValidateReplicaAsync(Map map, Viewpoint viewpoint)
{
var firstLayer = map.Basemap.BaseLayers.FirstOrDefault() as Layer;
string basemapUrl = string.Empty;
if (firstLayer is ArcGISTiledLayer)
{
var baseLayer = firstLayer as ArcGISTiledLayer;
basemapUrl = baseLayer.Source.AbsoluteUri;
}
if (!string.IsNullOrEmpty(basemapUrl))
{
var newBasemapUrl = basemapUrl.Contains("services.arcgisonline") ?
basemapUrl.Replace("services.arcgisonline", "tiledbasemaps.arcgis") :
basemapUrl;
var task = await ExportTileCacheTask.CreateAsync(new Uri(newBasemapUrl));
var param = await task.CreateDefaultExportTileCacheParametersAsync(viewpoint.TargetGeometry, MinScale, MaxScale);
var job = task.EstimateTileCacheSize(param);
try
{
var result = await job.GetResultAsync();
return(new ValidateReplicaResult
{
Valid = result.TileCount < task.ServiceInfo.MaxExportTilesCount,
Tiles = (int)result.TileCount,
Size = result.FileSize
});
}
catch (ArcGISRuntimeException ex)
{
Debug.WriteLine(ex.Message);
return(new ValidateReplicaResult());
}
}
return(new ValidateReplicaResult()
{
Valid = true
});
}
// Load the online basemap and dependent UI
private async void MyMapView_Loaded(object sender, RoutedEventArgs e)
{
await InitializeOnlineBasemap();
_aoiOverlay = new GraphicsOverlay()
{
Renderer = LayoutRoot.Resources["AOIRenderer"] as Renderer
};
MyMapView.GraphicsOverlays.Add(_aoiOverlay);
if (_onlineTiledLayer.ServiceInfo != null)
{
sliderLOD.Minimum = 0;
sliderLOD.Maximum = _onlineTiledLayer.ServiceInfo.TileInfo.Lods.Count - 1;
sliderLOD.Value = sliderLOD.Maximum;
}
_exportTilesTask = new ExportTileCacheTask(new Uri(_onlineTiledLayer.ServiceUri));
}
// Load the online basemap and dependent UI
private async void mapView_Loaded(object sender, RoutedEventArgs e)
{
await InitializeOnlineBasemap();
_aoiLayer = new GraphicsLayer()
{
ID = AOI_LAYER_ID, Renderer = layoutGrid.Resources["AOIRenderer"] as Renderer
};
mapView.Map.Layers.Add(_aoiLayer);
if (_onlineTiledLayer.ServiceInfo != null)
{
sliderLOD.Minimum = 0;
sliderLOD.Maximum = _onlineTiledLayer.ServiceInfo.TileInfo.Lods.Count - 1;
sliderLOD.Value = (int)(sliderLOD.Maximum / 2);
}
_exportTilesTask = new ExportTileCacheTask(new Uri(_onlineTiledLayer.ServiceUri));
}
/// <summary>
/// Starts the export job and registers callbacks to be notified of changes to job status
/// </summary>
private async void StartExport()
{
// Update the tile cache path
_tilePath = GetTilePath();
// Get the parameters for the job
ExportTileCacheParameters parameters = GetExportParameters();
// Create the task
ExportTileCacheTask exportTask = await ExportTileCacheTask.CreateAsync(_serviceUri);
// Create the export job
ExportTileCacheJob job = exportTask.ExportTileCache(parameters, _tilePath);
// Subscribe to notifications for status updates
job.JobChanged += Job_JobChanged;
// Start the export job
job.Start();
}
private async Task ExportTilesAsync(Geometry area, string downloadFolderPath, Uri uri)
{
var offlineTask = await ExportTileCacheTask.CreateAsync(uri);
var parameters = new ExportTileCacheParameters
{
AreaOfInterest = area,
CompressionQuality = 100
};
parameters.LevelIds.Add(4);
parameters.LevelIds.Add(6);
parameters.LevelIds.Add(8);
parameters.LevelIds.Add(12);
var job = offlineTask.ExportTileCache(parameters, downloadFolderPath + ".tpk");
job.Start();
await job.GetResultAsync();
}
private async Task StartExport()
{
// Get the parameters for the job.
ExportTileCacheParameters parameters = GetExportParameters();
// Create the task.
ExportTileCacheTask exportTask = await ExportTileCacheTask.CreateAsync(_serviceUri);
// Get the tile cache path.
_tilePath = $"{Path.GetTempFileName()}.tpk";
// Create the export job.
ExportTileCacheJob job = exportTask.ExportTileCache(parameters, _tilePath);
// Start the export job.
job.Start();
// Get the result.
TileCache cache = await job.GetResultAsync();
// Do the rest of the work.
await HandleExportComplete(job, cache);
}
private async Task StartExport()
{
// Get the parameters for the job.
ExportTileCacheParameters parameters = GetExportParameters();
// Create the task.
ExportTileCacheTask exportTask = await ExportTileCacheTask.CreateAsync(_serviceUri);
// Get the tile cache path.
string tilePath = Path.Combine(Environment.ExpandEnvironmentVariables("%TEMP%"), Path.GetTempFileName() + ".tpk");
// Create the export job.
ExportTileCacheJob job = exportTask.ExportTileCache(parameters, tilePath);
// Start the export job.
job.Start();
// Wait for the job to complete.
TileCache resultTileCache = await job.GetResultAsync();
// Do the rest of the work.
await HandleExportCompleted(job, resultTileCache);
}
private async Task StartExport()
{
try
{
// Update the tile cache path.
_tilePath = $"{Path.GetTempFileName()}.tpk";
// Get the parameters for the job.
ExportTileCacheParameters parameters = GetExportParameters();
// Create the task.
ExportTileCacheTask exportTask = await ExportTileCacheTask.CreateAsync(_serviceUri);
// Create the export job.
ExportTileCacheJob job = exportTask.ExportTileCache(parameters, _tilePath);
// Show the progress bar.
MyProgressBar.IsVisible = true;
// Start the export job.
job.Start();
// Get the tile cache result.
TileCache resultTileCache = await job.GetResultAsync();
// Hide the progress bar.
MyProgressBar.IsVisible = false;
// Do the rest of the work.
await HandleJobCompletion(job, resultTileCache);
}
catch (Exception ex)
{
await((Page)Parent).DisplayAlert("Error", ex.ToString(), "OK");
}
}
public static async Task <TileCache> DownloadOrUpdateTileService(String serviceUrl, Extent extent, Action <double, double> ProgressUpdate)
{
var task = new TaskCompletionSource <TileCache>();
// Create a task for generating a geodatabase (GeodatabaseSyncTask)
var etcTask = await ExportTileCacheTask.CreateAsync(new Uri(serviceUrl));
var serviceName = PullArcgisServiceName(serviceUrl);
var tileCacheFilePath = Path.Combine(CachePath, serviceName + ".tpk");
if (File.Exists(tileCacheFilePath))
{
// need to figure out how to update a tile cache
TileCache tileCache = new TileCache(tileCacheFilePath);
task.SetResult(tileCache);
}
else
{
var envelope = new Envelope(extent.MinX, extent.MinY, extent.MaxX, extent.MaxY, SpatialReference.Create(extent.WKID));
// Get the default parameters for the generate geodatabase task
var etcParams = await etcTask.CreateDefaultExportTileCacheParametersAsync(envelope, 0, 0);
// Create a generate geodatabase job
var etcJob = etcTask.ExportTileCache(etcParams, tileCacheFilePath);
// Handle the job changed event
etcJob.JobChanged += (async(object sender, EventArgs e) =>
{
var job = sender as ExportTileCacheJob;
switch (job?.Status)
{
case JobStatus.Succeeded:
TileCache tileCache = await etcJob.GetResultAsync();
task.SetResult(tileCache);
break;
case JobStatus.Failed:
if (etcJob.Error != null)
{
task.SetException(etcJob.Error);
}
else
{
String message = string.Empty;
var m = from msg in etcJob.Messages select msg.Message;
message += ": " + string.Join <string>("\n", m);
task.SetException(new Exception(message));
}
task.SetResult(null);
break;
}
});
// Handle the progress changed event (to show progress bar)
etcJob.ProgressChanged += ((object sender, EventArgs e) =>
{
ProgressUpdate?.Invoke(etcJob.Progress, 1.0);
});
// Start the job
etcJob.Start();
}
return(await task.Task);
}
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;
}
}
public static async void LoadCache(CacheSettings cache)
{
Logging.LogMethodCall(MethodBase.GetCurrentMethod().DeclaringType.Name, () => new Dictionary <String, Object> {
{ nameof(cache), cache }
});
if (cache == null)
{
throw new ArgumentNullException("cache");
}
try
{
if (File.Exists(CacheFilePath(cache.IsBaseMap, cache.Name, false, true)))
{
if (File.Exists(CacheFilePath(cache.IsBaseMap, cache.Name, true, true)))
{
File.Delete(CacheFilePath(cache.IsBaseMap, cache.Name, true, true));
}
if (cache.IsBaseMap || true)//handle not purge on sync
{
File.Move(CacheFilePath(cache.IsBaseMap, cache.Name, false, true), CacheFilePath(cache.IsBaseMap, cache.Name, true, true));
}
else
{
File.Copy(CacheFilePath(cache.IsBaseMap, cache.Name, false, true), CacheFilePath(cache.IsBaseMap, cache.Name, true, true));
}
}
if (File.Exists(CacheFilePath(cache.IsBaseMap, cache.Name, true, true)))
{
try
{
if (cache.IsBaseMap)
{
TileCacheLoaded.Invoke(null, new TileCacheLoadedEventArgs(cache.Name, new TileCache(CacheFilePath(cache.IsBaseMap, cache.Name, true, true)), null));
}
else
{
GeodatabaseLoaded.Invoke(null, new GeodatabaseLoadedEventArgs(cache.Name, await Geodatabase.OpenAsync(CacheFilePath(cache.IsBaseMap, cache.Name, true, true)), null));
}
}
catch (Exception ex)
{
if (cache.IsBaseMap)
{
TileCacheLoaded.Invoke(null, new TileCacheLoadedEventArgs(cache.Name, null, ex));
}
else
{
GeodatabaseLoaded.Invoke(null, new GeodatabaseLoadedEventArgs(cache.Name, null, ex));
}
}
if (cache.SyncType == CacheSyncTypes.AdminSync && File.GetLastWriteTime(CacheFilePath(cache.IsBaseMap, cache.Name, true, true)) >= cache.LastUpdate)
{
return;
}
}
if (cache.SyncType == CacheSyncTypes.NeverSync)
{
return;
}
if (cache.IsBaseMap)
{
// Create a task for generating a geodatabase (GeodatabaseSyncTask)
var etcTask = await ExportTileCacheTask.CreateAsync(new Uri(cache.URL));
// Get the default parameters for the generate geodatabase task
var etcParams = await etcTask.CreateDefaultExportTileCacheParametersAsync(etcTask.ServiceInfo.FullExtent, etcTask.ServiceInfo.MinScale, etcTask.ServiceInfo.MaxScale);
// Create a generate geodatabase job
var etcJob = etcTask.ExportTileCache(etcParams, CacheFilePath(cache.IsBaseMap, cache.Name, false, false));
// Handle the job changed event
etcJob.JobChanged += (object sender, EventArgs e) =>
{
JobStatus status = etcJob.Status;
// If the job completed successfully, add the geodatabase data to the map
if (status == JobStatus.Succeeded)
{
File.Move(CacheFilePath(cache.IsBaseMap, cache.Name, false, false), CacheFilePath(cache.IsBaseMap, cache.Name, false, true));
TileCacheLoaded.Invoke(null, new TileCacheLoadedEventArgs(cache.Name, new TileCache(CacheFilePath(cache.IsBaseMap, cache.Name, false, true)), null));
}
// See if the job failed
if (status == JobStatus.Failed)
{
// Create a message to show the user
string message = "Generate tile cache job failed";
// Show an error message (if there is one)
if (etcJob.Error != null)
{
message += ": " + etcJob.Error.Message;
}
else
{
// If no error, show messages from the job
var m = from msg in etcJob.Messages select msg.Message;
message += ": " + string.Join <string>("\n", m);
}
TileCacheLoaded.Invoke(null, new TileCacheLoadedEventArgs(cache.Name, null, new Exception(message)));
}
};
// Handle the progress changed event (to show progress bar)
etcJob.ProgressChanged += ((object sender, EventArgs e) =>
{
String message = String.Format("Loading {0}", cache.Name);
CacheUpdating.Invoke(null, new CacheUpdatingEventArgs(message, etcJob.Progress, 100));
});
// Start the job
etcJob.Start();
}
else
{
// Create a task for generating a geodatabase (GeodatabaseSyncTask)
var gdbSyncTask = await GeodatabaseSyncTask.CreateAsync(new Uri(cache.URL));
// Get the default parameters for the generate geodatabase task
GenerateGeodatabaseParameters generateParams = await gdbSyncTask.CreateDefaultGenerateGeodatabaseParametersAsync(gdbSyncTask.ServiceInfo.FullExtent);
// Create a generate geodatabase job
gdbJob = gdbSyncTask.GenerateGeodatabase(generateParams, CacheFilePath(cache.IsBaseMap, cache.Name, false, false));
// Handle the job changed event
gdbJob.JobChanged += (async(object sender, EventArgs e) =>
{
var job = sender as GenerateGeodatabaseJob;
// See if the job failed
if (job.Status == JobStatus.Failed)
{
// Create a message to show the user
string message = "Generate geodatabase job failed";
// Show an error message (if there is one)
if (job.Error != null)
{
message += ": " + job.Error.Message;
}
else
{
// If no error, show messages from the job
var m = from msg in job.Messages select msg.Message;
message += ": " + string.Join <string>("\n", m);
}
GeodatabaseLoaded.Invoke(null, new GeodatabaseLoadedEventArgs(cache.Name, null, new Exception(message)));
}
if (job.Status == JobStatus.Succeeded)
{
// Get the new geodatabase
var _currentGeodatabase = await job.GetResultAsync();
// Best practice is to unregister the geodatabase
await gdbSyncTask.UnregisterGeodatabaseAsync(_currentGeodatabase);
_currentGeodatabase.Close();
File.Move(CacheFilePath(cache.IsBaseMap, cache.Name, false, false), CacheFilePath(cache.IsBaseMap, cache.Name, false, true));
var old = await Geodatabase.OpenAsync(CacheFilePath(cache.IsBaseMap, cache.Name, false, true));
GeodatabaseLoaded.Invoke(null, new GeodatabaseLoadedEventArgs(cache.Name, old, null));
}
});
// Handle the progress changed event (to show progress bar)
gdbJob.ProgressChanged += ((object sender, EventArgs e) =>
{
String message = String.Format("Loading {0}", cache.Name);
CacheUpdating.Invoke(null, new CacheUpdatingEventArgs(message, gdbJob.Progress, 100));
});
// Start the job
gdbJob.Start();
}
}
catch (Exception ex)
{
if (cache.IsBaseMap)
{
TileCacheLoaded.Invoke(null, new TileCacheLoadedEventArgs(cache.Name, null, ex));
}
else
{
GeodatabaseLoaded.Invoke(null, new GeodatabaseLoadedEventArgs(cache.Name, null, ex));
}
}
}
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;
}
