// 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 }); }
/// <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; }