private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap.
MyMapView.Map = new Map(BasemapStyle.ArcGISStreets);
// Get the path to the downloaded mobile geodatabase (.geodatabase file).
string mobileGeodatabaseFilePath = GetMobileGeodatabasePath();
try
{
// Open the mobile geodatabase.
Geodatabase mobileGeodatabase = await Geodatabase.OpenAsync(mobileGeodatabaseFilePath);
// Get the 'Trailheads' geodatabase feature table from the mobile geodatabase.
GeodatabaseFeatureTable trailheadsGeodatabaseFeatureTable = mobileGeodatabase.GeodatabaseFeatureTable("Trailheads");
// Asynchronously load the 'Trailheads' geodatabase feature table.
await trailheadsGeodatabaseFeatureTable.LoadAsync();
// Create a feature layer based on the geodatabase feature table.
FeatureLayer trailheadsFeatureLayer = new FeatureLayer(trailheadsGeodatabaseFeatureTable);
// Add the feature layer to the operations layers collection of the map.
MyMapView.Map.OperationalLayers.Add(trailheadsFeatureLayer);
// Zoom the map to the extent of the feature layer.
await MyMapView.SetViewpointGeometryAsync(trailheadsFeatureLayer.FullExtent, 50);
}
catch (Exception e)
{
await Application.Current.MainPage.DisplayAlert("Error", e.ToString(), "OK");
}
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap.
MyMapView.Map = new Map(Basemap.CreateStreets());
// Get the path to the downloaded mobile geodatabase (.geodatabase file).
string mobileGeodatabaseFilePath = GetMobileGeodatabasePath();
// Open the mobile geodatabase.
Geodatabase mobileGeodatabase = await Geodatabase.OpenAsync(mobileGeodatabaseFilePath);
// Get the 'Trailheads' geodatabase feature table from the mobile geodatabase.
GeodatabaseFeatureTable trailheadsGeodatabaseFeatureTable = mobileGeodatabase.GeodatabaseFeatureTable("Trailheads");
// Asynchronously load the 'Trailheads' geodatabase feature table.
await trailheadsGeodatabaseFeatureTable.LoadAsync();
// Create a feature layer based on the geodatabase feature table.
FeatureLayer trailheadsFeatureLayer = new FeatureLayer(trailheadsGeodatabaseFeatureTable);
// Add the feature layer to the operations layers collection of the map.
MyMapView.Map.OperationalLayers.Add(trailheadsFeatureLayer);
// Zoom the map to the extent of the feature layer.
await MyMapView.SetViewpointGeometryAsync(trailheadsFeatureLayer.FullExtent);
}
// Function that loads the two point tables from the local geodatabase and displays them as feature layers
private async void LoadLocalGeodatabaseTables()
{
// Read the geodatabase tables and add them as layers
foreach (GeodatabaseFeatureTable table in _localGeodatabase.GeodatabaseFeatureTables)
{
// Load the table so the TableName can be read
await table.LoadAsync();
// Store a reference to the Birds table
if (table.TableName.ToLower().Contains("birds"))
{
_birdTable = table;
}
// Store a reference to the Marine table
if (table.TableName.ToLower().Contains("marine"))
{
_marineTable = table;
}
// Create a new feature layer to show the table in the map
var layer = new FeatureLayer(table);
Dispatcher.Invoke(() => MyMapView.Map.OperationalLayers.Add(layer));
}
// Handle the transaction status changed event
_localGeodatabase.TransactionStatusChanged += GdbTransactionStatusChanged;
// Zoom the map view to the extent of the generated local datasets
Dispatcher.Invoke(() =>
{
MyMapView.SetViewpointGeometryAsync(_marineTable.Extent);
StartEditingButton.IsEnabled = true;
});
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap.
_myMapView.Map = new Map(Basemap.CreateStreets());
// Get the path to the downloaded mobile geodatabase (.geodatabase file).
string mobileGeodatabaseFilePath = DataManager.GetDataFolder("2b0f9e17105847809dfeb04e3cad69e0", "LA_Trails.geodatabase");
try
{
// Open the mobile geodatabase.
Geodatabase mobileGeodatabase = await Geodatabase.OpenAsync(mobileGeodatabaseFilePath);
// Get the 'Trailheads' geodatabase feature table from the mobile geodatabase.
GeodatabaseFeatureTable trailheadsGeodatabaseFeatureTable = mobileGeodatabase.GeodatabaseFeatureTable("Trailheads");
// Asynchronously load the 'Trailheads' geodatabase feature table.
await trailheadsGeodatabaseFeatureTable.LoadAsync();
// Create a feature layer based on the geodatabase feature table.
FeatureLayer trailheadsFeatureLayer = new FeatureLayer(trailheadsGeodatabaseFeatureTable);
// Add the feature layer to the operations layers collection of the map.
_myMapView.Map.OperationalLayers.Add(trailheadsFeatureLayer);
// Zoom the map to the extent of the feature layer.
await _myMapView.SetViewpointGeometryAsync(trailheadsFeatureLayer.FullExtent, 50);
}
catch (Exception e)
{
new UIAlertView("Error", e.ToString(), (IUIAlertViewDelegate)null, "OK", null).Show();
}
}
// Summary:
// Add a layer in a geodatabase (aka. local layer)
// The name of the layer and display options are specified in the LocalELayer
//
public static async Task <IGraphicsLayer> addGeodatabaseLayer(
Map map, LayerDef layerDef, GeodatabaseFeatureTable table,
int start = 0, int maxFeatures = 0)
{
if (layerDef == null || table == null)
{
return(null);
}
IS3GraphicsLayer gLayer = await featureTable2GraphicsLayer(
map, table, start, maxFeatures);
if (gLayer == null)
{
return(null);
}
gLayer.ID = table.Name;
gLayer.MinScale = table.ServiceInfo.MinScale;
gLayer.MaxScale = table.ServiceInfo.MaxScale;
setGraphicLayerDisplayOptions(layerDef, gLayer);
map.Layers.Add(gLayer);
return(gLayer);
}
private async void Initialize()
{
// Create a new map to display in the map view with a streets basemap.
_myMapView.Map = new Map(Basemap.CreateStreets());
// Get the path to the downloaded mobile geodatabase (.geodatabase file).
string mobileGeodatabaseFilePath = GetMobileGeodatabasePath();
try
{
// Open the mobile geodatabase.
Geodatabase mobileGeodatabase = await Geodatabase.OpenAsync(mobileGeodatabaseFilePath);
// Get the 'Trailheads' geodatabase feature table from the mobile geodatabase.
GeodatabaseFeatureTable trailheadsGeodatabaseFeatureTable = mobileGeodatabase.GeodatabaseFeatureTable("Trailheads");
// Asynchronously load the 'Trailheads' geodatabase feature table.
await trailheadsGeodatabaseFeatureTable.LoadAsync();
// Create a feature layer based on the geodatabase feature table.
FeatureLayer trailheadsFeatureLayer = new FeatureLayer(trailheadsGeodatabaseFeatureTable);
// Add the feature layer to the operations layers collection of the map.
_myMapView.Map.OperationalLayers.Add(trailheadsFeatureLayer);
// Zoom the map to the extent of the feature layer.
await _myMapView.SetViewpointGeometryAsync(trailheadsFeatureLayer.FullExtent, 50);
}
catch (Exception e)
{
new AlertDialog.Builder(this).SetMessage(e.ToString()).SetTitle("Error").Show();
}
}
public static LayerDef GenerateDefaultLayerDef(GeodatabaseFeatureTable table)
{
LayerDef lyrDef = new LayerDef();
lyrDef.Name = table.Name;
lyrDef.IsVisible = true;
if (table.GeometryType == GeometryType.Point)
{
lyrDef.GeometryType = IS3.Core.Geometry.GeometryType.Point;
lyrDef.Color = Colors.Red;
lyrDef.FillStyle = SimpleFillStyle.Solid;
lyrDef.EnableLabel = true;
lyrDef.LabelTextExpression = "[Name]";
}
else if (table.GeometryType == GeometryType.Polyline)
{
lyrDef.GeometryType = IS3.Core.Geometry.GeometryType.Polyline;
lyrDef.OutlineColor = Colors.Green;
lyrDef.Color = Colors.Green;
lyrDef.FillStyle = SimpleFillStyle.Solid;
}
else if (table.GeometryType == GeometryType.Polygon)
{
lyrDef.GeometryType = IS3.Core.Geometry.GeometryType.Polygon;
lyrDef.OutlineColor = Colors.Blue;
lyrDef.Color = Colors.Blue;
lyrDef.FillStyle = SimpleFillStyle.Solid;
}
return(lyrDef);
}
// Summary:
// Add a layer in a geodatabase (aka. local layer)
// The name of the layer and display options are specified in the LocalELayer
//
public async Task <IGraphicsLayer> addGeodatabaseLayer(LayerDef layerDef,
Geodatabase gdb, int start = 0, int maxFeatures = 0)
{
if (layerDef == null || gdb == null)
{
return(null);
}
GeodatabaseFeatureTable table =
gdb.FeatureTables.FirstOrDefault(t => t.Name == layerDef.Name);
if (table == null)
{
return(null);
}
IS3GraphicsLayer gLayer = await featureTable2GraphicsLayer(
table, start, maxFeatures, false);
if (gLayer == null)
{
return(null);
}
gLayer.ID = layerDef.Name;
gLayer.MinScale = table.ServiceInfo.MinScale;
gLayer.MaxScale = table.ServiceInfo.MaxScale;
setGraphicLayerDisplayOptions(layerDef, gLayer);
_map.Layers.Add(gLayer);
return(gLayer);
}
public async void SearchByMeterID(string searchString)
{
SimpleLineSymbol sls = new SimpleLineSymbol()
{
Color = System.Windows.Media.Colors.Red,
Style = SimpleLineStyle.Solid,
Width = 2
};
// get the layer and table
FeatureLayer featureLayer = this.mapView.Map.Layers[1] as FeatureLayer;
GeodatabaseFeatureTable table = featureLayer.FeatureTable as GeodatabaseFeatureTable;
// Define an attribute query
var filter = new Esri.ArcGISRuntime.Data.QueryFilter();
filter.WhereClause = "POST_ID = '" + searchString + "'"; // 666-13080
// Execute the query and await results
IEnumerable <Feature> features = await table.QueryAsync(filter);
// iterate the feature. Should be one in this case.
foreach (Feature feature in features)
{
// Get the MapPoint, Project to Mercator so that we are working in meters
MapPoint mapPoint = feature.Geometry as MapPoint;
MapPoint pointMercator = GeometryEngine.Project(mapPoint, SpatialReferences.WebMercator) as MapPoint;
Geometry polygon = GeometryEngine.Buffer(pointMercator, 200);
// Re-project the polygon to WGS84 so that we can query against the layer which is in WGS84
Polygon polygonWgs84 = GeometryEngine.Project(polygon, SpatialReferences.Wgs84) as Polygon;
// add the circle (buffer)
Graphic graphic = new Graphic();
graphic.Symbol = sls;
graphic.Geometry = polygonWgs84;
this.graphicsLayer.Graphics.Add(graphic);
// Make sure the table supports querying
if (table.SupportsQuery)
{
// setup the query to use the polygon that's in WGS84
var query = new Esri.ArcGISRuntime.Data.SpatialQueryFilter();
query.Geometry = polygonWgs84 as Geometry;
query.SpatialRelationship = SpatialRelationship.Intersects;
var result = await table.QueryAsync(query);
int i = 1;
// Loop through query results
foreach (Esri.ArcGISRuntime.Data.Feature f in result)
{
// do something with results
System.Diagnostics.Debug.WriteLine(i.ToString());
i++;
}
}
}
}
private async Task UnregisterAndRemoveMobileMapPackage(MobileMapPackage mobileMapPackage)
{
// Unregister all geodatabases from all maps that are part of the mobile map package.
// Offline areas that are downloaded by using OfflineMapTask will contain a single
// map in them but it is a good practice to handle the case of multiple maps.
foreach (Map map in mobileMapPackage.Maps)
{
// Find all geodatabases from the used map.
List <Geodatabase> geodatabasesToUnregister = new List <Geodatabase>();
// Add all geodatabases used in the feature layers.
foreach (FeatureLayer featureLayer in map.OperationalLayers.OfType <FeatureLayer>())
{
GeodatabaseFeatureTable geodatabaseFeatureTable = featureLayer.FeatureTable as GeodatabaseFeatureTable;
if (geodatabaseFeatureTable == null)
{
continue;
}
// Add the geodatabase feature table if it isn't already in the list.
if (geodatabasesToUnregister.All(x => x.Path != geodatabaseFeatureTable.Geodatabase.Path))
{
geodatabasesToUnregister.Add(geodatabaseFeatureTable.Geodatabase);
}
}
// Add all geodatabases used in a table.
foreach (FeatureTable featureTable in map.Tables)
{
GeodatabaseFeatureTable geodatabaseFeatureTable = featureTable as GeodatabaseFeatureTable;
if (geodatabaseFeatureTable == null)
{
continue;
}
// Add the geodatabase feature table if it isn't already in the list.
if (geodatabasesToUnregister.All(x => x.Path != geodatabaseFeatureTable.Geodatabase.Path))
{
geodatabasesToUnregister.Add(geodatabaseFeatureTable.Geodatabase);
}
}
// Unregister geodatabases that were used.
foreach (Geodatabase geodatabaseToUnregister in geodatabasesToUnregister)
{
GeodatabaseSyncTask geodatabaSyncTask = await GeodatabaseSyncTask.CreateAsync(geodatabaseToUnregister.Source);
await geodatabaSyncTask.UnregisterGeodatabaseAsync(geodatabaseToUnregister);
}
// Make sure that all geodatabases are closed and locks released.
foreach (Geodatabase geodatabase in geodatabasesToUnregister)
{
geodatabase.Close();
}
}
// Remove package.
Directory.Delete(mobileMapPackage.Path, true);
}
private async void AddNewFeature(object sender, EventArgs args)
{
// See if it was the "Birds" or "Marine" button that was clicked
Button addFeatureButton = (Button)sender;
try
{
// Cancel execution of the sketch task if it is already active
if (_mapView.SketchEditor.CancelCommand.CanExecute(null))
{
_mapView.SketchEditor.CancelCommand.Execute(null);
}
// Store the correct table to edit (for the button clicked)
GeodatabaseFeatureTable editTable = null;
if (addFeatureButton == _addBirdButton)
{
editTable = _birdTable;
}
else
{
editTable = _marineTable;
}
// Inform the user which table is being edited
_messageTextBlock.Text = "Click the map to add a new feature to the geodatabase table '" + editTable.TableName + "'";
// Create a random value for the 'type' attribute (integer between 1 and 7)
Random random = new Random(DateTime.Now.Millisecond);
int featureType = random.Next(1, 7);
// Use the sketch editor to allow the user to draw a point on the map
MapPoint clickPoint = await _mapView.SketchEditor.StartAsync(SketchCreationMode.Point, false) as MapPoint;
// Create a new feature (row) in the selected table
Feature newFeature = editTable.CreateFeature();
// Set the geometry with the point the user clicked and the 'type' with the random integer
newFeature.Geometry = clickPoint;
newFeature.SetAttributeValue("type", featureType);
// Add the new feature to the table
await editTable.AddFeatureAsync(newFeature);
// Clear the message
_messageTextBlock.Text = "New feature added to the '" + editTable.TableName + "' table";
}
catch (TaskCanceledException)
{
// Ignore if the edit was canceled
}
catch (Exception ex)
{
// Report other exception messages
_messageTextBlock.Text = ex.Message;
}
}
/// <summary>
/// Adds a MMPK map source.
/// </summary>
/// <param name="fileName">the MMPK file</param>
/// <returns>the opened MMPK</returns>
public async Task <MobileMapPackage> AddMMPKAsync(string fileName)
{
List <Map> maps = new List <Map>();
MobileMapPackage mmpk = null;
if (!this.HasLayerFileSource(fileName))
{
LayerFileSource lfs = new LayerFileSource();
lfs.SourceFile = fileName;
this.LayerFileSources.Add(lfs);
mmpk = await MobileMapPackage.OpenAsync(fileName);
await mmpk.LoadAsync();
foreach (Map aMap in mmpk.Maps)
{
maps.Add(aMap);
var layerCollection = aMap.OperationalLayers.Reverse();
await aMap.LoadAsync();
Trace.WriteLine("Map = " + aMap.ToString());
foreach (var layer in layerCollection)
{
Layer lyr = layer.Clone();
lyr.IsVisible = layer.IsVisible;
//if (layer.Opacity == 1)
// layer.Opacity = .55;
lyr.Opacity = layer.Opacity;
await lyr.LoadAsync();
if (lyr is FeatureLayer)
{
TesterLayer testLayer = new TesterLayer();
FeatureLayer featLyr = lyr as FeatureLayer;
GeodatabaseFeatureTable featureTable = featLyr.FeatureTable as GeodatabaseFeatureTable;
testLayer.FeatureTable = featureTable;
testLayer.FeatureLayer = featLyr;
lfs.Children.Add(testLayer);
((FeatureLayer)lyr).LabelsEnabled = true;
((FeatureLayer)lyr).DefinitionExpression = ((FeatureLayer)layer).DefinitionExpression;
}
else if (lyr is GroupLayer)
{
SetupLayersUnderGroupLayer((GroupLayer)lyr, (GroupLayer)layer, lfs);
}
this.Map.OperationalLayers.Add(lyr);
}
}
}
return(mmpk);
}
/// <summary>
/// Copies the definition expressions from any feature layers under the source layer to the matching feature layers under the target layer.
/// </summary>
/// <param name="targetLayer">the target group layer</param>
/// <param name="sourceLayer">the source group layer</param>
private static void SetupLayersUnderGroupLayer(GroupLayer targetLayer, GroupLayer sourceLayer, LayerFileSource lfs)
{
Dictionary <string, string> defExprs = new Dictionary <string, string>();
//
// Collect all definition expressions.
//
foreach (Layer srcChildLayer in sourceLayer.Layers)
{
if (srcChildLayer is FeatureLayer)
{
TesterLayer testLayer = new TesterLayer();
testLayer.FeatureLayer = srcChildLayer as FeatureLayer;
GeodatabaseFeatureTable featureTable = testLayer.FeatureLayer.FeatureTable as GeodatabaseFeatureTable;
testLayer.FeatureTable = featureTable;
lfs.Children.Add(testLayer);
FeatureLayer srcLayer = (FeatureLayer)srcChildLayer;
string defExpr = srcLayer.DefinitionExpression;
if (!string.IsNullOrEmpty(defExpr))
{
defExprs[srcLayer.Name] = defExpr;
}
}
}
//
// Apply all definition expressions. Cache them as derived.
//
foreach (Layer tgtChildLayer in targetLayer.Layers)
{
if (tgtChildLayer is FeatureLayer)
{
TesterLayer testLayer = new TesterLayer();
testLayer.FeatureLayer = tgtChildLayer as FeatureLayer;
GeodatabaseFeatureTable featureTable = testLayer.FeatureLayer.FeatureTable as GeodatabaseFeatureTable;
testLayer.FeatureTable = featureTable;
lfs.Children.Add(testLayer);
FeatureLayer tgtLayer = (FeatureLayer)tgtChildLayer;
tgtLayer.LabelsEnabled = true;
// This will apply the mapservice name to the feature layer under the group layers so that
// the results from this layer will be under the same map service or else it will be in a different set
// under a system generated hashcode for this layer.
tgtLayer.Id = targetLayer.Id;
if (defExprs.ContainsKey(tgtLayer.Name))
{
tgtLayer.DefinitionExpression = defExprs[tgtLayer.Name];
}
}
}
}
/// <summary>
/// Adds a SQLite geodatabase to the list of layers.
/// </summary>
/// <param name="pathToGeodatabase">the file to be loaded</param>
/// <returns>simply a marker indicating that things completed (true all good, false not all good)</returns>
public async Task <bool> AddSQLiteGeodatabaseAsync(string pathToGeodatabase)
{
bool allGood = true;
if (!this.HasLayerFileSource(pathToGeodatabase))
{
LayerFileSource lfs = new LayerFileSource();
lfs.SourceFile = pathToGeodatabase;
this.LayerFileSources.Add(lfs);
Geodatabase gdb = await Geodatabase.OpenAsync(pathToGeodatabase);
//
// Store the test layers.
//
foreach (GeodatabaseFeatureTable gft in gdb.GeodatabaseFeatureTables)
{
TesterLayer testLayer = new TesterLayer();
testLayer.FeatureTable = gft;
gft.PropertyChanged += GeodbFeatTab_PropertyChanged;
lfs.Children.Add(testLayer);
}
//
// Now load them all.
//
foreach (TesterLayer tl in lfs.Children)
{
GeodatabaseFeatureTable gtab = tl.FeatureTable;
try
{
await gtab.LoadAsync();
FeatureLayer fLayer = new FeatureLayer(gtab);
fLayer.PropertyChanged += FeatureLayer_PropertyChanged;
await fLayer.LoadAsync();
fLayer.LabelsEnabled = true;
this.Map.OperationalLayers.Add(fLayer);
tl.FeatureLayer = fLayer;
}
catch (Exception exc)
{
tl.LayerLoadException = exc;
allGood = false;
tl.LoadDone = true;
}
}
}
return(allGood);
}
private async void HandleGenerationStatusChange(GenerateGeodatabaseJob job)
{
JobStatus status = job.Status;
// Job が成功したら作成した ローカル ジオデータベース をマップに追加する
if (status == JobStatus.Succeeded)
{
// 既存のレイヤーをクリア
//myMapView.Map.OperationalLayers.Clear();
myMapView.Map.OperationalLayers.RemoveAt(0);
// 新しいローカル ジオデータベース を取得
_resultGdb = await job.GetResultAsync();
mGdbFeatureTable = _resultGdb.GeodatabaseFeatureTables.FirstOrDefault();
// テーブから新しいフィーチャ レイヤを作成する
FeatureLayer layer = new FeatureLayer(mGdbFeatureTable);
// 新しいレイヤーをマップに追加する
myMapView.Map.OperationalLayers.Add(layer);
// 編集機能を有効にする
_readyForEdits = EditState.Ready;
}
// ジオデータベースの作成ジョブに失敗した時
if (status == JobStatus.Failed)
{
// エラーメッセージの作成
string message = "ジオデータベースの作成に失敗";
// エラーメッセージを表示する（存在する場合）
if (job.Error != null)
{
message += ": " + job.Error.Message;
}
else
{
// エラーがなければ、ジョブからのメッセージを表示する
foreach (JobMessage m in job.Messages)
{
// JobMessage からテキストを取得し、出力文字列に追加します
message += "\n" + m.Message;
}
}
// メッセージを表示する
ShowStatusMessage(message);
}
}
/// <summary>
/// Executes ViewModel initialization logic. Called when ViewModel is created from base view model.
/// </summary>
protected override async Task InitializeAsync()
{
// Create map with layers
Map = new Map()
{
InitialExtent = new Envelope(-14161146.113642, 3137996.40676956, -7626168.31478212, 6574986.2928574)
};
// Basemap layer from ArcGIS Online hosted service
var basemap = new ArcGISLocalTiledLayer()
{
ID = "Basemap",
DisplayName = "Basemap",
Path = @"../../../../Data/TileCaches/Topographic.tpk"
};
// Initialize layer in Try - Catch
Exception exceptionToHandle = null;
try
{
await basemap.InitializeAsync();
Map.Layers.Add(basemap);
// Open geodatbase and find States feature table
var geodatabase = await Geodatabase.OpenAsync(@"../../../../Data/Databases/usa.geodatabase");
_featureTable = geodatabase.FeatureTables.First(x => x.Name == "States");
// Create graphics layer for start and endpoints
CreateGraphicsLayers();
IsInitialized = true;
}
catch (Exception exception)
{
// Exception is thrown ie if layer url is not found - ie. {"Error code '400' : 'Invalid URL'"}
exceptionToHandle = exception;
}
if (exceptionToHandle != null)
{
// Initialization failed, show message and return
await MessageService.Instance.ShowMessage(string.Format(
"Could not create basemap. Error = {0}", exceptionToHandle.ToString()),
"An error occured");
return;
}
}
// Function that loads the two point tables from the local geodatabase and displays them as feature layers
private async void LoadLocalGeodatabaseTables()
{
if (_localGeodatabase == null)
{
return;
}
// Read the geodatabase tables and add them as layers
foreach (GeodatabaseFeatureTable table in _localGeodatabase.GeodatabaseFeatureTables)
{
try
{
// Load the table so the TableName can be read
await table.LoadAsync();
// Store a reference to the Birds table
if (table.TableName.ToLower().Contains("birds"))
{
_birdTable = table;
}
// Store a reference to the Marine table
if (table.TableName.ToLower().Contains("marine"))
{
_marineTable = table;
}
// Create a new feature layer to show the table in the map
FeatureLayer layer = new FeatureLayer(table);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => MyMapView.Map.OperationalLayers.Add(layer));
}
catch (Exception e)
{
await new MessageDialog(e.ToString(), "Error").ShowAsync();
}
}
// Handle the transaction status changed event
_localGeodatabase.TransactionStatusChanged += GdbTransactionStatusChanged;
// Zoom the map view to the extent of the generated local datasets
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
MyMapView.SetViewpoint(new Viewpoint(_marineTable.Extent));
StartEditingButton.IsEnabled = true;
});
}
// Function that loads the two point tables from the local geodatabase and displays them as feature layers
private async void LoadLocalGeodatabaseTables()
{
if (_localGeodatabase == null)
{
return;
}
// Read the geodatabase tables and add them as layers
foreach (GeodatabaseFeatureTable table in _localGeodatabase.GeodatabaseFeatureTables)
{
try
{
// Load the table so the TableName can be read
await table.LoadAsync();
// Store a reference to the Birds table
if (table.TableName.ToLower().Contains("birds"))
{
_birdTable = table;
}
// Store a reference to the Marine table
if (table.TableName.ToLower().Contains("marine"))
{
_marineTable = table;
}
// Create a new feature layer to show the table in the map
FeatureLayer layer = new FeatureLayer(table);
Device.BeginInvokeOnMainThread(() => MyMapView.Map.OperationalLayers.Add(layer));
}
catch (Exception e)
{
await((Page)Parent).DisplayAlert("Error", e.ToString(), "OK");
}
}
// Handle the transaction status changed event
_localGeodatabase.TransactionStatusChanged += GdbTransactionStatusChanged;
// Zoom the map view to the extent of the generated local datasets
Device.BeginInvokeOnMainThread(() =>
{
MyMapView.SetViewpoint(new Viewpoint(_marineTable.Extent));
StartEditingButton.IsEnabled = true;
});
}
// Function that loads the two point tables from the local geodatabase and displays them as feature layers
private async void LoadLocalGeodatabaseTables()
{
if (_localGeodatabase == null)
{
return;
}
// Read the geodatabase tables and add them as layers
foreach (GeodatabaseFeatureTable table in _localGeodatabase.GeodatabaseFeatureTables)
{
try
{
// Load the table so the TableName can be read
await table.LoadAsync();
// Store a reference to the Birds table
if (table.TableName.ToLower().Contains("birds"))
{
_birdTable = table;
}
// Store a reference to the Marine table
if (table.TableName.ToLower().Contains("marine"))
{
_marineTable = table;
}
// Create a new feature layer to show the table in the map
FeatureLayer layer = new FeatureLayer(table);
RunOnUiThread(() => _mapView.Map.OperationalLayers.Add(layer));
}
catch (Exception e)
{
new AlertDialog.Builder(this).SetMessage(e.ToString()).SetTitle("Error").Show();
}
}
// Handle the transaction status changed event
_localGeodatabase.TransactionStatusChanged += GdbTransactionStatusChanged;
// Zoom the map view to the extent of the generated local datasets
RunOnUiThread(() =>
{
_mapView.SetViewpoint(new Viewpoint(_marineTable.Extent));
_startEditingButton.Enabled = true;
});
}
// Function that loads the two point tables from the local geodatabase and displays them as feature layers.
private async Task LoadLocalGeodatabaseTables()
{
if (_localGeodatabase == null)
{
return;
}
// Read the geodatabase tables and add them as layers.
foreach (GeodatabaseFeatureTable table in _localGeodatabase.GeodatabaseFeatureTables)
{
try
{
// Load the table so the TableName can be read.
await table.LoadAsync();
// Store a reference to the Birds table.
if (table.TableName.ToLower().Contains("birds"))
{
_birdTable = table;
}
// Store a reference to the Marine table.
if (table.TableName.ToLower().Contains("marine"))
{
_marineTable = table;
}
// Create a new feature layer to show the table in the map.
FeatureLayer layer = new FeatureLayer(table);
InvokeOnMainThread(() => _mapView.Map.OperationalLayers.Add(layer));
}
catch (Exception e)
{
new UIAlertView("Error", e.ToString(), (IUIAlertViewDelegate)null, "OK", null).Show();
}
}
// Handle the transaction status changed event.
_localGeodatabase.TransactionStatusChanged += GdbTransactionStatusChanged;
// Zoom the map view to the extent of the generated local datasets.
InvokeOnMainThread(() =>
{
_mapView.SetViewpoint(new Viewpoint(_marineTable.Extent));
_transactionButton.Enabled = true;
});
}
public static LayerDef GenerateDefaultLayerDef(GeodatabaseFeatureTable table)
{
IS3.Core.Geometry.GeometryType geomType = IS3.Core.Geometry.GeometryType.Point;
if (table.GeometryType == GeometryType.Point)
{
geomType = IS3.Core.Geometry.GeometryType.Point;
}
else if (table.GeometryType == GeometryType.Polyline)
{
geomType = IS3.Core.Geometry.GeometryType.Polyline;
}
else if (table.GeometryType == GeometryType.Polygon)
{
geomType = IS3.Core.Geometry.GeometryType.Polygon;
}
return(GenerateDefaultLayerDef(table.Name, geomType));
}
private async void AddNewFeature(bool isMarine)
{
try
{
// Cancel execution of the sketch task if it is already active.
if (_mapView.SketchEditor.CancelCommand.CanExecute(null))
{
_mapView.SketchEditor.CancelCommand.Execute(null);
}
// Store the correct table to edit (for the button clicked).
GeodatabaseFeatureTable editTable = isMarine ? _marineTable : _birdTable;
// Inform the user which table is being edited.
_statusLabel.Text = "Click the map to add a new feature to the geodatabase table '" + editTable.TableName + "'";
// Create a random value for the 'type' attribute (integer between 1 and 7).
Random random = new Random(DateTime.Now.Millisecond);
int featureType = random.Next(1, 7);
// Use the sketch editor to allow the user to draw a point on the map.
MapPoint clickPoint = await _mapView.SketchEditor.StartAsync(SketchCreationMode.Point, false) as MapPoint;
// Create a new feature (row) in the selected table.
Feature newFeature = editTable.CreateFeature();
// Set the geometry with the point the user clicked and the 'type' with the random integer.
newFeature.Geometry = clickPoint;
newFeature.SetAttributeValue("type", featureType);
// Add the new feature to the table.
await editTable.AddFeatureAsync(newFeature);
// Clear the message.
_statusLabel.Text = "New feature added to the '" + editTable.TableName + "' table";
}
catch (TaskCanceledException)
{
// Ignore if the edit was canceled.
}
catch (Exception ex)
{
// Report other exception messages.
_statusLabel.Text = ex.Message;
}
}
public async void Search(string searchString)
{
FeatureLayer featureLayer = this.mapView.Map.Layers[1] as FeatureLayer;
GeodatabaseFeatureTable table = featureLayer.FeatureTable as GeodatabaseFeatureTable;
// Define an attribute query
var filter = new Esri.ArcGISRuntime.Data.QueryFilter();
filter.WhereClause = "POST_ID = '" + searchString + "'"; // 666-13080
// Execute the query and await results
IEnumerable <Feature> features = await table.QueryAsync(filter);
foreach (Feature feature in features)
{
string address = feature.Attributes["STREETNAME"] as string;
System.Diagnostics.Debug.WriteLine("Address: " + address);
}
}
private async void readGeoDatabase()
{
geodatabase = await Geodatabase.OpenAsync(mGeodatabasePath);
if (geodatabase.GeodatabaseFeatureTables.Count > 0)
{
// データベース内の最初のテーブルを取得する
mGdbFeatureTable = geodatabase.GeodatabaseFeatureTables.FirstOrDefault();
await mGdbFeatureTable.LoadAsync();
if (mGdbFeatureTable.LoadStatus == LoadStatus.Loaded)
{
myMap.OperationalLayers.RemoveAt(0);
mFeatureLayer = new FeatureLayer(mGdbFeatureTable);
myMap.OperationalLayers.Add(mFeatureLayer);
}
}
}
/// <summary>
/// マップビュー読み込み時のイベント ハンドラ
/// </summary>
private async void mapView_Loaded(object sender, RoutedEventArgs e)
{
try
{
//ローカル ジオデータベース（Runtime コンテンツ）のフィーチャ テーブルを読み込み
var gdb = await Geodatabase.OpenAsync(GDB_PATH);
_gdbTable = gdb.FeatureTables.FirstOrDefault();
//フィーチャ テーブルに設定されたレンダラ―（シンボル情報）を取得
_graphicsLayer = new GraphicsLayer() { RenderingMode = GraphicsRenderingMode.Static };
_graphicsLayer.Renderer = _gdbTable.ServiceInfo.DrawingInfo.Renderer;
//フィーチャを表示
var features = await _gdbTable.QueryAsync(new QueryFilter() { WhereClause = GetFilterTest() });
_graphicsLayer.GraphicsSource = features.Select(f => new Graphic(f.Geometry));
//マップにグラフィックスレイヤーを追加
mapView.Map.Layers.Add(_graphicsLayer);
}
catch (Exception ex)
{
MessageBox.Show(string.Format("フィーチャ レイヤーの作成に失敗しました: {0}", ex.Message));
}
}
private void GeodbFeatTab_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
GeodatabaseFeatureTable featTab = (GeodatabaseFeatureTable)sender;
Trace.WriteLine("Geodatabase property changed = " + e.PropertyName + " against " + featTab.TableName);
}
private async void GeoViewTapped(object sender, GeoViewInputEventArgs e)
{
try
{
// Disregard if not ready for edits.
if (_readyForEdits == EditState.NotReady)
{
return;
}
// If an edit is in process, finish it.
if (_readyForEdits == EditState.Editing)
{
// Hold a list of any selected features.
List <Feature> selectedFeatures = new List <Feature>();
// Get all selected features then clear selection.
foreach (FeatureLayer layer in myMapView.Map.OperationalLayers)
{
// Get the selected features.
FeatureQueryResult layerFeatures = await layer.GetSelectedFeaturesAsync();
// FeatureQueryResult implements IEnumerable, so it can be treated as a collection of features.
selectedFeatures.AddRange(layerFeatures);
// Clear the selection.
layer.ClearSelection();
}
// Update all selected features' geometry.
foreach (Feature feature in selectedFeatures)
{
// Get a reference to the correct feature table for the feature.
GeodatabaseFeatureTable table = (GeodatabaseFeatureTable)feature.FeatureTable;
// Ensure the geometry type of the table is point.
if (table.GeometryType != GeometryType.Point)
{
continue;
}
// Set the new geometry.
feature.Geometry = e.Location;
// Update the feature in the table.
await table.UpdateFeatureAsync(feature);
}
// Update the edit state.
_readyForEdits = EditState.Ready;
// Enable the sync button.
mySyncButton.IsEnabled = true;
// Update the help label.
MyHelpLabel.Text = "4. Click 'Synchronize' or keep editing";
}
// Otherwise, start an edit.
else
{
// Define a tolerance for use with identifying the feature.
double tolerance = 15 * myMapView.UnitsPerPixel;
// Define the selection envelope.
Envelope selectionEnvelope = new Envelope(e.Location.X - tolerance, e.Location.Y - tolerance, e.Location.X + tolerance, e.Location.Y + tolerance);
// Define query parameters for feature selection.
QueryParameters query = new QueryParameters()
{
Geometry = selectionEnvelope
};
// Select the feature in all applicable tables.
foreach (FeatureLayer layer in myMapView.Map.OperationalLayers)
{
await layer.SelectFeaturesAsync(query, SelectionMode.New);
}
// Set the edit state.
_readyForEdits = EditState.Editing;
// Update the help label.
MyHelpLabel.Text = "3. Tap on the map to move the point";
}
}
catch (Exception ex)
{
await((Page)Parent).DisplayAlert("Error", ex.ToString(), "OK");
}
}
/// <summary>
/// Creates a frequency analysis file for the specified table.
/// </summary>
/// <param name="outputFile">the file to which to write the analysis</param>
/// <param name="table">the table to analyse</param>
/// <returns>did things go well?</returns>
public async Task <bool> RunFrequencyAnalysis(string outputFile, GeodatabaseFeatureTable table)
{
bool allGood = true;
long totalRecs = table.NumberOfFeatures;
Dictionary <string, Dictionary <string, uint> > freqs = new Dictionary <string, Dictionary <string, uint> >();
string whereClause = "1=1";
string orderingName = null;
long lastOID = 0;
int lastBatchCount = -1;
long totalRecordsProcessed = 0;
int recordsPerBatch = 10000;
foreach (Field aField in table.Fields)
{
if (aField.FieldType == FieldType.OID)
{
orderingName = aField.Name;
whereClause = aField.Name + " > " + lastOID + " order by " + aField.Name;
break;
}
}
try
{
while (lastBatchCount != 0)
{
QueryParameters queryParams = new QueryParameters();
queryParams.ReturnGeometry = true;
lastBatchCount = 0;
if (orderingName == null)
{
queryParams.WhereClause = "1=1";
}
else
{
queryParams.WhereClause = orderingName + " > " + lastOID + " order by " + orderingName;
}
FeatureQueryResult result = await table.QueryFeaturesAsync(queryParams);
IEnumerator <Feature> features = result.GetEnumerator();
object attValue = null;
string attStringValue = null;
//
// Collect the frequencies.
//
while (features.MoveNext())
{
Feature aFeature = features.Current;
totalRecordsProcessed++;
lastBatchCount++;
foreach (string attName in aFeature.Attributes.Keys)
{
attValue = aFeature.Attributes[attName];
if (attValue == null)
{
attStringValue = "";
}
else
{
attStringValue = attValue.ToString();
}
this.StoreFrequency(attName, attStringValue, freqs);
if (orderingName.Equals(attName))
{
lastOID = (long)attValue;
}
}
if (totalRecordsProcessed % 2500 == 0)
{
Trace.WriteLine("Processed " + totalRecordsProcessed + " out of " + table.NumberOfFeatures);
}
if (lastBatchCount == recordsPerBatch)
{
features.Dispose();
break;
}
}
}
//
// Write out the frequencies.
//
using (StreamWriter writer = new StreamWriter(outputFile))
{
foreach (string attributeName in freqs.Keys)
{
Dictionary <string, uint> attributeFreqs = freqs[attributeName];
if (attributeFreqs.Count > 200)
{
writer.Write("\"");
writer.Write(attributeName);
writer.Write("\"");
writer.Write(",");
writer.Write("\"");
writer.Write("<MANY VALUES>");
writer.Write("\"");
writer.Write(",");
writer.Write(table.NumberOfFeatures);
writer.Write("\n");
}
else
{
foreach (string attributeValue in attributeFreqs.Keys)
{
uint numVals = attributeFreqs[attributeValue];
writer.Write("\"");
writer.Write(attributeName);
writer.Write("\"");
writer.Write(",");
writer.Write("\"");
writer.Write(attributeValue);
writer.Write("\"");
writer.Write(",");
writer.Write(numVals);
writer.Write("\n");
}
}
}
}
}
catch (Exception e)
{
allGood = false;
string excString = "=====================\n";
excString = excString + e.Message + "\n";
excString = excString + e.StackTrace + "\n";
this.LoggingText = excString;
}
return(allGood);
}
/// <summary>
/// Executes ViewModel initialization logic. Called when ViewModel is created from base view model.
/// </summary>
protected override async Task InitializeAsync()
{
// Create map with layers
Map = new Map()
{
InitialExtent = new Envelope(-14161146.113642, 3137996.40676956, -7626168.31478212, 6574986.2928574)
};
// Basemap layer from ArcGIS Online hosted service
var basemap = new ArcGISLocalTiledLayer()
{
ID = "Basemap",
DisplayName = "Basemap",
Path = @"../../../../Data/TileCaches/Topographic.tpk"
};
// Initialize layer in Try - Catch
Exception exceptionToHandle = null;
try
{
await basemap.InitializeAsync();
Map.Layers.Add(basemap);
// Open geodatbase and find States feature table
var geodatabase = await Geodatabase.OpenAsync(@"../../../../Data/Databases/usa.geodatabase");
_featureTable = geodatabase.FeatureTables.First(x => x.Name == "States");
// Create graphics layer for start and endpoints
CreateGraphicsLayers();
IsInitialized = true;
}
catch (Exception exception)
{
// Exception is thrown ie if layer url is not found - ie. {"Error code '400' : 'Invalid URL'"}
exceptionToHandle = exception;
}
if (exceptionToHandle != null)
{
// Initialization failed, show message and return
await MessageService.Instance.ShowMessage(string.Format(
"Could not create basemap. Error = {0}", exceptionToHandle.ToString()),
"An error occured");
return;
}
}
private async void GeoViewTapped(object sender, Esri.ArcGISRuntime.UI.Controls.GeoViewInputEventArgs e)
{
try
{
// Disregard if not ready for edits.
if (_readyForEdits == EditState.NotReady)
{
return;
}
// If an edit is in process, finish it.
if (_readyForEdits == EditState.Editing)
{
// Hold a list of any selected features.
List <Feature> selectedFeatures = new List <Feature>();
// Get all selected features then clear selection.
foreach (FeatureLayer layer in MyMapView.Map.OperationalLayers)
{
// Get the selected features.
FeatureQueryResult layerFeatures = await layer.GetSelectedFeaturesAsync();
// FeatureQueryResult implements IEnumerable, so it can be treated as a collection of features.
selectedFeatures.AddRange(layerFeatures);
// Clear the selection.
layer.ClearSelection();
}
// Update all selected feature geometry.
foreach (Feature feature in selectedFeatures)
{
// Get a reference to the correct feature table for the feature.
GeodatabaseFeatureTable table = (GeodatabaseFeatureTable)feature.FeatureTable;
// Ensure the geometry type of the table is point.
if (table.GeometryType != GeometryType.Point)
{
continue;
}
// Set the new geometry.
feature.Geometry = e.Location;
try
{
// Update the feature in the table.
await table.UpdateFeatureAsync(feature);
}
catch (Esri.ArcGISRuntime.ArcGISException)
{
ShowStatusMessage("Feature must be within extent of geodatabase.");
}
}
// Update the edit state.
_readyForEdits = EditState.Ready;
// Enable the sync button.
SyncButton.IsEnabled = true;
// Update the help label.
MyHelpLabel.Text = "4. Click 'Sync' or edit more features";
}
// Otherwise, start an edit.
else
{
// Define a tolerance for use with identifying the feature.
double tolerance = 15 * MyMapView.UnitsPerPixel;
// Define the selection envelope.
Envelope selectionEnvelope = new Envelope(e.Location.X - tolerance, e.Location.Y - tolerance, e.Location.X + tolerance, e.Location.Y + tolerance);
// Define query parameters for feature selection.
QueryParameters query = new QueryParameters()
{
Geometry = selectionEnvelope
};
// Track whether any selections were made.
bool selectedFeature = false;
// Select the feature in all applicable tables.
foreach (FeatureLayer layer in MyMapView.Map.OperationalLayers)
{
FeatureQueryResult res = await layer.SelectFeaturesAsync(query, SelectionMode.New);
selectedFeature = selectedFeature || res.Any();
}
// Only update state if a feature was selected.
if (selectedFeature)
{
// Set the edit state.
_readyForEdits = EditState.Editing;
// Update the help label.
MyHelpLabel.Text = "3. Tap on the map to move the point";
}
}
}
catch (Exception ex)
{
ShowStatusMessage(ex.ToString());
}
}
private void GetOutputLocations(GeodatabaseFeatureTable table, FileInfo file, out string copyToFolder, out string copyToFile)
{
copyToFolder = Path.Combine(_attachmentOutFolder, table.TableName);
copyToFile = Path.Combine(copyToFolder, file.Name);
}
private async void GeoViewTapped(object sender, GeoViewInputEventArgs e)
{
// Disregard if not ready for edits
if (_readyForEdits == EditState.NotReady)
{
return;
}
// If an edit is in process, finish it
if (_readyForEdits == EditState.Editing)
{
// Hold a list of any selected features
List <Feature> selectedFeatures = new List <Feature>();
// Get all selected features then clear selection
foreach (FeatureLayer layer in myMapView.Map.OperationalLayers)
{
// Get the selected features
FeatureQueryResult layerFeatures = await layer.GetSelectedFeaturesAsync();
// FeatureQueryResult implements IEnumerable, so it can be treated as a collection of features
selectedFeatures.AddRange(layerFeatures);
// Clear the selection
layer.ClearSelection();
}
// Update all selected features' geometry
foreach (Feature feature in selectedFeatures)
{
// Get a reference to the correct feature table for the feature
GeodatabaseFeatureTable table = feature.FeatureTable as GeodatabaseFeatureTable;
// Ensure the geometry type of the table is point
if (table.GeometryType != GeometryType.Point)
{
continue;
}
// Set the new geometry
feature.Geometry = e.Location;
// Update the feature in the table
await table.UpdateFeatureAsync(feature);
}
// Update the edit state
_readyForEdits = EditState.Ready;
// Enable the sync button
mySyncButton.Enabled = true;
}
// Otherwise, start an edit
else
{
// Define a tolerance for use with identifying the feature
double tolerance = 15 * myMapView.UnitsPerPixel;
// Define the selection envelope
Envelope selectionEnvelope = new Envelope(e.Location.X - tolerance, e.Location.Y - tolerance, e.Location.X + tolerance, e.Location.Y + tolerance);
// Define query parameters for feature selection
QueryParameters query = new QueryParameters()
{
Geometry = selectionEnvelope
};
// Select the feature in all applicable tables
foreach (FeatureLayer layer in myMapView.Map.OperationalLayers)
{
await layer.SelectFeaturesAsync(query, SelectionMode.New);
}
// Set the edit state
_readyForEdits = EditState.Editing;
}
}
