private async void AddAttachment(Android.Net.Uri imageUri)
{
string contentType = "image/jpeg";
// Read the image into a stream.
Stream stream = ContentResolver.OpenInputStream(imageUri);
// Read from the stream into the byte array.
byte[] attachmentData;
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
attachmentData = memoryStream.ToArray();
}
// Add the attachment.
// The contentType string is the MIME type for JPEG files, image/jpeg.
await _selectedFeature.AddAttachmentAsync(imageUri.LastPathSegment + ".jpg", contentType, attachmentData);
// Get a reference to the feature's service feature table.
ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable;
// Apply the edits to the service feature table.
await serviceTable.ApplyEditsAsync();
// Update UI.
_selectedFeature.Refresh();
_featureAttachments = await _selectedFeature.GetAttachmentsAsync();
UpdateUIForFeature();
ShowMessage("Successfully added attachment", "Success!");
}
private async void AddAttachment(UITableView tableView)
{
// Get the image to upload.
Stream imageStream = await GetImageStreamAsync();
if (imageStream == null)
{
return;
}
// Convert the image stream into a byte array.
byte[] attachmentData = new byte[imageStream.Length];
imageStream.Read(attachmentData, 0, attachmentData.Length);
// Determine the file name.
string filename = _filename ?? "iOS_image_1.jpg";
// Add the attachment.
// The contentType string is the MIME type for JPEG files, image/jpeg.
await _selectedFeature.AddAttachmentAsync(filename, "image/jpeg", attachmentData);
// Get a reference to the feature's service feature table.
ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable;
// Apply the edits to the service feature table.
await serviceTable.ApplyEditsAsync();
// Update UI.
_selectedFeature.Refresh();
_attachments = await _selectedFeature.GetAttachmentsAsync();
tableView.ReloadData();
_viewController.ShowMessage("Successfully added attachment", "Success!");
}
private async Task CreateFeature(Image capturedImage, int healthValue)
{
_helpLabel.Text = "Adding feature...";
try
{
// Get the geometry of the feature.
MapPoint featurePoint = _graphicsOverlay.Graphics.First().Geometry as MapPoint;
// Create attributes for the feature using the user selected health value.
IEnumerable <KeyValuePair <string, object> > featureAttributes = new Dictionary <string, object>()
{
{ "Health", (short)healthValue }, { "Height", 3.2 }, { "Diameter", 1.2 }
};
// Ensure that the feature table is loaded.
if (_featureTable.LoadStatus != Esri.ArcGISRuntime.LoadStatus.Loaded)
{
await _featureTable.LoadAsync();
}
// Create the new feature
ArcGISFeature newFeature = _featureTable.CreateFeature(featureAttributes, featurePoint) as ArcGISFeature;
// Convert the Image from ARCore into a JPEG byte array.
byte[] attachmentData = await ConvertImageToJPEG(capturedImage);
// Add the attachment.
// The contentType string is the MIME type for JPEG files, image/jpeg.
await newFeature.AddAttachmentAsync("tree.jpg", "image/jpeg", attachmentData);
// Add the newly created feature to the feature table.
await _featureTable.AddFeatureAsync(newFeature);
// Apply the edits to the service feature table.
await _featureTable.ApplyEditsAsync();
// Reset the user interface.
_helpLabel.Text = "Tap to create a feature";
_graphicsOverlay.Graphics.Clear();
_addButton.Enabled = false;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
ShowMessage("Could not create feature", "Error");
}
}
private async void AddAttachment_Click(object sender, RoutedEventArgs e)
{
if (_selectedFeature == null)
{
return;
}
// Adjust the UI.
AddAttachmentButton.IsEnabled = false;
ActivityIndicator.Visibility = Visibility.Visible;
// Get the file.
string contentType = "image/jpeg";
byte[] attachmentData;
try
{
// Show a file picker.
// Allow the user to specify a file path - create the picker.
FileOpenPicker openPicker = new FileOpenPicker();
openPicker.FileTypeFilter.Add(".jpg");
// Show the picker.
StorageFile file = await openPicker.PickSingleFileAsync();
// Take action if the user selected a file.
if (file == null)
{
return;
}
// Read the file contents into memory.
Stream dataStream = await file.OpenStreamForReadAsync();
attachmentData = new byte[dataStream.Length];
dataStream.Read(attachmentData, 0, attachmentData.Length);
dataStream.Close();
// Add the attachment.
// The contentType string is the MIME type for JPEG files, image/jpeg.
await _selectedFeature.AddAttachmentAsync(file.Name, contentType, attachmentData);
// Get a reference to the feature's service feature table.
ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable;
// Apply the edits to the service feature table.
await serviceTable.ApplyEditsAsync();
// Update UI.
_selectedFeature.Refresh();
AttachmentsListBox.ItemsSource = await _selectedFeature.GetAttachmentsAsync();
await new MessageDialog2("Successfully added attachment", "Success!").ShowAsync();
}
catch (Exception exception)
{
await new MessageDialog2(exception.ToString(), "Error adding attachment").ShowAsync();
}
finally
{
// Adjust the UI.
AddAttachmentButton.IsEnabled = true;
ActivityIndicator.Visibility = Visibility.Collapsed;
}
}
private async void AddAttachment_Click(object sender, EventArgs e)
{
if (_selectedFeature == null)
{
return;
}
// Adjust the UI.
AddAttachmentButton.IsEnabled = false;
AttachmentActivityIndicator.IsVisible = true;
// Get the file.
string contentType = "image/jpeg";
try
{
byte[] attachmentData;
string filename;
// Xamarin.Plugin.FilePicker shows the iCloud picker (not photo picker) on iOS.
// This iOS code shows the photo picker.
#if __IOS__
Stream imageStream = await GetImageStreamAsync();
if (imageStream == null)
{
return;
}
attachmentData = new byte[imageStream.Length];
imageStream.Read(attachmentData, 0, attachmentData.Length);
filename = _filename ?? "file1.jpeg";
#else
// Show a file picker - this uses the Xamarin.Plugin.FilePicker NuGet package.
FileData fileData = await CrossFilePicker.Current.PickFile(new[] { ".jpg", ".jpeg" });
if (fileData == null)
{
return;
}
if (!fileData.FileName.EndsWith(".jpg") && !fileData.FileName.EndsWith(".jpeg"))
{
await Application.Current.MainPage.DisplayAlert("Try again!", "This sample only allows uploading jpg files.", "OK");
return;
}
attachmentData = fileData.DataArray;
filename = fileData.FileName;
#endif
// Add the attachment.
// The contentType string is the MIME type for JPEG files, image/jpeg.
await _selectedFeature.AddAttachmentAsync(filename, contentType, attachmentData);
// Get a reference to the feature's service feature table.
ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable;
// Apply the edits to the service feature table.
await serviceTable.ApplyEditsAsync();
// Update UI.
_selectedFeature.Refresh();
AttachmentsListBox.ItemsSource = await _selectedFeature.GetAttachmentsAsync();
await Application.Current.MainPage.DisplayAlert("Success!", "Successfully added attachment", "OK");
}
catch (Exception exception)
{
await Application.Current.MainPage.DisplayAlert("Error adding attachment", exception.ToString(), "OK");
}
finally
{
// Adjust the UI.
AddAttachmentButton.IsEnabled = true;
AttachmentActivityIndicator.IsVisible = false;
}
}
private async void AddAttachment_Click(object sender, RoutedEventArgs e)
{
if (_selectedFeature == null)
{
return;
}
// Adjust the UI.
AddAttachmentButton.IsEnabled = false;
ActivityIndicator.Visibility = Visibility.Visible;
try
{
// Show a file dialog.
// Allow the user to specify a file path - create the dialog.
OpenFileDialog dlg = new OpenFileDialog
{
DefaultExt = ".jpg",
Filter = "Image Files(*.JPG;*.JPEG)|*.JPG;*.JPEG",
InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures)
};
// Show the dialog and get the results.
bool?result = dlg.ShowDialog();
// Take action if the user selected a file.
if (result != true)
{
return;
}
// Get the name of the file from the full path (dlg.FileName is the full path).
string filename = Path.GetFileName(dlg.FileName);
// Create a stream for reading the file.
FileStream fs = new FileStream(dlg.FileName,
FileMode.Open,
FileAccess.Read);
// Create a binary reader from the stream.
BinaryReader br = new BinaryReader(fs);
// Populate the attachment data with the binary content.
long numBytes = new FileInfo(dlg.FileName).Length;
byte[] attachmentData = br.ReadBytes((int)numBytes);
// Close the stream.
fs.Close();
// Add the attachment.
// The contentType string is the MIME type for JPEG files, image/jpeg.
await _selectedFeature.AddAttachmentAsync(filename, "image/jpeg", attachmentData);
// Get a reference to the feature's service feature table.
ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable;
// Apply the edits to the service feature table.
await serviceTable.ApplyEditsAsync();
// Update UI.
_selectedFeature.Refresh();
AttachmentsListBox.ItemsSource = await _selectedFeature.GetAttachmentsAsync();
MessageBox.Show("Successfully added attachment", "Success!");
}
catch (Exception exception)
{
MessageBox.Show(exception.ToString(), "Error adding attachment");
}
finally
{
// Adjust the UI.
AddAttachmentButton.IsEnabled = true;
ActivityIndicator.Visibility = Visibility.Collapsed;
}
}
