public async void AddPhoto()
{
if (!CrossMedia.Current.IsPickPhotoSupported)
{
await Application.Current.MainPage.DisplayAlert("No upload", "Picking a photo is not supported", "Ok");
return;
}
file = await CrossMedia.Current.PickPhotoAsync();
if (file == null)
{
return;
}
ImageS = ImageSource.FromStream(() => file.GetStream()).ToString();
}
public CameraSavePage(Plugin.Media.Abstractions.MediaFile passImage)
{
InitializeComponent();
SaveButton.Clicked += SaveButton_Clicked;
btnNewTag.Clicked += BtnNewTag_Clicked;
btnAddTag.Clicked += BtnAddTag_Clicked;
btnRemoveTag.Clicked += BtnRemoveTag_Clicked;
btnResetTags.Clicked += BtnResetTags_Clicked;
//init the necessary data
pictureData.rating = 0;
pictureData.tags = new List <String>();
spinner.ItemsSource = jsonTB.GetTags();
saveImage = passImage;
setupFillData(passImage);
}
private async void AddImage_Clicked(object sender, EventArgs e)
{
if (this.BugImage.IsEnabled)
{
switch (await this.DisplayActionSheet("Image Options", "Cancel", "Remove", "Change"))
{
case "Cancel":
return;
case "Remove":
this.BugImage.IsEnabled = false;
this.BugImageFrame.IsEnabled = false;
this.BugImageFrame.IsVisible = false;
this.ImagePath = null;
return;
case "Change":
default:
break;
}
}
await CrossMedia.Current.Initialize();
Plugin.Media.Abstractions.MediaFile file = await CrossMedia.Current.PickPhotoAsync();
if (file != null) // if the user actually picked an image
{
MemoryStream memoryStream = new MemoryStream();
file.GetStream().CopyTo(memoryStream);
if (memoryStream.Length < 3000000)
{
this.BugImage.IsEnabled = true;
this.BugImageFrame.IsEnabled = true;
this.BugImageFrame.IsVisible = true;
this.BugImage.Source = FileImageSource.FromFile(file.Path);
this.ImagePath = file.Path;
}
else
{
await this.DisplayAlert("Couldn't use Picture", "Pictures must be under 3 MB", "Back");
}
file.Dispose();
}
}
private async void ImageButton_ClickedAsync(object sender, EventArgs e)
{
if (!CrossMedia.Current.IsPickPhotoSupported)
{
await DisplayAlert("no upload", "picking a photo is not supported", "Ok");
return;
}
file = await CrossMedia.Current.PickPhotoAsync();
if (file == null)
{
return;
}
Image.Source = ImageSource.FromStream(() => file.GetStream());
}
private async void ImageChoose()
{
try
{
await CrossMedia.Current.Initialize();
Plugin.Media.Abstractions.MediaFile file = await CrossMedia.Current.PickPhotoAsync(new Plugin.Media.Abstractions.PickMediaOptions()
{
PhotoSize = Plugin.Media.Abstractions.PhotoSize.Medium,
CompressionQuality = 80
});
if (file == null)
{
return;
}
Acr.UserDialogs.UserDialogs.Instance.ShowLoading(AppResource.alertLoading);
imgProduct.Source = ImageSource.FromStream(() =>
{
Stream img = file.GetStream();
return(img);
});
Stream stream = file.GetStream();
byte[] imageData;
using (MemoryStream ms = new MemoryStream())
{
stream.CopyTo(ms);
imageData = ms.ToArray();
}
_imageStream = new MemoryStream(imageData);
}
catch (Exception ex)
{
ex.ToString();
}
finally
{
Acr.UserDialogs.UserDialogs.Instance.HideLoading();
}
}
private async Task InsertFaultPicture(Plugin.Media.Abstractions.MediaFile picture)
{
byte[] pictureBytes;
using (var memoryStream = new MemoryStream())
{
picture.GetStream().CopyTo(memoryStream);
picture.Dispose();
pictureBytes = memoryStream.ToArray();
}
var dbPicture = new FaultPicture
{
Picture = pictureBytes,
FaultId = faultContext.FaultId
};
await DatabaseService.InsertFaultPicture(dbPicture);
}
private async Task takePhoto()
{
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
{
await DisplayAlert("מצלמה לא זמינה", "וודא שקיימת הרשאה למצלמה", "חזור");
m_Photo = null;
}
else
{
m_Photo = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions
{
PhotoSize = Plugin.Media.Abstractions.PhotoSize.Small, //******
Directory = "Sample",
Name = "test.jpg"
});
}
}
public static async Task <IMediaFile> Convert(this Plugin.Media.Abstractions.MediaFile source)
{
if (source != null)
{
var extension = Path.GetExtension(source.Path);
extension = string.IsNullOrEmpty(extension) ? null : extension;
using (var mediaStream = source.GetStream())
using (var memoryStream = new MemoryStream())
{
await mediaStream.CopyToAsync(memoryStream);
return(new MediaFile(extension, memoryStream.ToArray()));
}
}
else
{
return(null);
}
}
public async void PickPhoto_Tapped()
{
currcount = 0;
ClassifierResult_Label.Text = string.Empty;
Plugin.Media.Abstractions.MediaFile file = null;
await CrossMedia.Current.Initialize();
try
{
file = await CrossMedia.Current.PickPhotoAsync(new Plugin.Media.Abstractions.PickMediaOptions
{
PhotoSize = Plugin.Media.Abstractions.PhotoSize.Medium
});
if (file == null)
{
return;
}
SelectedImageSource = ImageSource.FromStream(() =>
{
try
{
var stream = file.GetStream();
return(stream);
}
catch
{
return(null);
}
});
ClassifierResult = await Classifier.GetImageTags(file.GetStream());
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
public async Task Convert()
{
var bytes = new byte[] { 1 };
var media = new Plugin.Media.Abstractions.MediaFile("/hoge/foo/bar/image.jpg", () => new MemoryStream(bytes));
var actual = await media.Convert();
Assert.NotNull(actual);
Assert.Equal(".jpg", actual.Extension);
using (var sourceStream = actual.GetStream())
using (var memoryStream = new MemoryStream())
{
Assert.NotNull(sourceStream);
sourceStream.CopyTo(memoryStream);
var actualArray = memoryStream.ToArray();
Assert.Equal(1, actualArray.Length);
Assert.Equal(bytes[0], actualArray[0]);
}
}
public string SaveFotoFromAlbum(string caminhoFoto, Plugin.Media.Abstractions.MediaFile file)
{
string nomeArquivo;
if (caminhoFoto == null || caminhoFoto.StartsWith("http"))
{
nomeArquivo = String.Format("{0:ddMMyyy_HHmm}", DateTime.Now) + ".jpg";
}
else
{
if (File.Exists(DependencyService.Get <IFotoLoadMediaPlugin>().GetPathToPhoto(caminhoFoto)))
{
File.Delete(DependencyService.Get <IFotoLoadMediaPlugin>().GetPathToPhoto(caminhoFoto));
}
nomeArquivo = (caminhoFoto.LastIndexOf("/") > 0) ? caminhoFoto.Substring(caminhoFoto.LastIndexOf("/") + 1) : caminhoFoto;
}
viewModel.NomeArquivo = nomeArquivo;
return(file.Path);
}
private async void FromCamera()
{
try
{
if (!CrossMedia.Current.IsPickPhotoSupported)
{
DisplayAlert("Photos Not Supported", ":( Permission not granted to photos.", "OK");
return;
}
profileData = await Plugin.Media.CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions
{
PhotoSize = Plugin.Media.Abstractions.PhotoSize.Medium
});
if (profileData == null)
{
return;
}
imgProfile.Source = ImageSource.FromStream(() =>
{
var stream = profileData.GetStream();
//file.Dispose();
return(stream);
});
var bytearray = StaticMethods.StreamToByte(profileData.GetStream());
var base64 = Convert.ToBase64String(bytearray);
var extsn = Path.GetExtension(profileData.Path);
var str = extsn.Split('.');
extsn = str[1];
UpdateProfilePic(base64, extsn);
}
catch (Exception ex)
{
}
}
private async Task GetPhotoCam()
{
try
{
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
{
DependencyService.Get <IMessage>().ShortAlert("No camera available.");
await Navigation.PopModalAsync();
}
Plugin.Media.Abstractions.MediaFile file = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions
{
Directory = "Profile_Pictures",
Name = $"Confessor{Guid.NewGuid().ToString().Replace("-", "")}.png",
SaveToAlbum = true,
AllowCropping = true,
DefaultCamera = Plugin.Media.Abstractions.CameraDevice.Front,
SaveMetaData = true
});
if (file == null)
{
await Navigation.PopModalAsync();
}
else
{
Stream stream = file.GetStream();
bufferMemory = Logic.GetByteArrayFromString(stream);
ProcessPhotoInStream(stream);
}
}
catch (Exception ex)
{
Crashes.TrackError(ex, Logic.GetErrorProperties(ex));
await Navigation.PopModalAsync();
}
}
private async void TakePhoto_Clicked(object sender, EventArgs e)
{
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
{
await DisplayAlert("No Camera", ":( No camera available.", "OK");
return;
}
theImage = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions
{
SaveToAlbum = true,
Name = "test.jpg"
});
MyImage.Source = ImageSource.FromStream(() =>
{
var stream = theImage.GetStream();
return(stream);
});
}
public NewImagePage(Document document)
{
InitializeComponent();
_document = document;
takePhoto.Clicked += async(sender, args) =>
{
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
{
await DisplayAlert("No Camera", ":( No camera avaialble.", "OK");
return;
}
var file = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions
{
PhotoSize = Plugin.Media.Abstractions.PhotoSize.Small,
Directory = "Sample",
Name = "test.jpg",
SaveToAlbum = true
});
if (file == null)
{
return;
}
_file = file;
image.Source = ImageSource.FromStream(() =>
{
var stream = file.GetStream();
return(stream);
});
};
}
private void Llenar()
{
Movimientos mv1 = new Movimientos
{
ID = "",
observ = "Ninguna",
producto = users1[0].nombre,
marca = users1[0].marca,
modelo = users1[0].modelo,
IdProducto = users1[0].ID,
codigo = users1[0].codigo,
serie = users1[0].serie,
cantidad = "1",
foto = "",
movimiento = "Retirar",
lugar = " ",
fecha = DateTime.Now.ToString("dd/MM/yyyy")
};
mv.Add(mv1);
f2.Add(f);
f1.Add(f);
f = null;
}
/// <summary>
/// Send picture to Azure, then return status
/// </summary>
/// <param name="photo">Photo taken by the player</param>
/// <returns>True if success, False if something append</returns>
async Task <bool> IGameRepository.SendValidationPic(Plugin.Media.Abstractions.MediaFile photo)
{
try
{
HttpContent fileStreamContent = new StreamContent(photo.GetStream());
fileStreamContent.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("form-data")
{
Name = "file", FileName = CurrentUser.Player.Login + "-" + CurrentUser.CurrentStep.StepId + ".png"
};
fileStreamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
using (var client = new HttpClient())
using (var formData = new MultipartFormDataContent())
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + CurrentUser.Token);
formData.Add(fileStreamContent);
var response = await client.PostAsync(PedaGoServers.BaseApiUrl + "/api/uploadValidationPhoto", formData);
if (response.IsSuccessStatusCode)
{
return(true);
}
else
{
return(false);
}
}
}
catch
{
return(false);
}
}
private async void FromLibrary()
{
try
{
if (!isMultipleSelection)
{
if (!CrossMedia.Current.IsPickPhotoSupported)
{
DisplayAlert("Photos Not Supported", ":( Permission not granted to photos.", "OK");
return;
}
profileData = await Plugin.Media.CrossMedia.Current.PickPhotoAsync(new Plugin.Media.Abstractions.PickMediaOptions
{
PhotoSize = Plugin.Media.Abstractions.PhotoSize.Medium
});
if (profileData == null)
{
return;
}
SetImage(fromImageView, profileData);
gvSingleImage.IsVisible = false;
gvMultipleImage.IsVisible = true;
}
else
{
var list = await DependencyService.Get <IiOSMethods>().MultiImagePicker();
}
}
catch (Exception ex)
{
}
}
private void RemoveImage(int flag)
{
try
{
switch (flag)
{
case 1:
img1.Source = "camera";
imageFillCounter1 = 0;
_file1 = null;
break;
case 2:
img2.Source = "camera";
imageFillCounter2 = 0;
_file2 = null;
break;
case 3:
img3.Source = "camera";
imageFillCounter3 = 0;
_file3 = null;
break;
case 4:
img4.Source = "camera";
imageFillCounter4 = 0;
_file4 = null;
break;
}
}
catch (Exception ex)
{
}
}
private async void SelectImage_Clicked(object sender, EventArgs e)
{
var actionSheet = await DisplayActionSheet("Tuỳ chọn", "Đóng", null, "Chụp ảnh", "Chọn ảnh");
Plugin.Media.Abstractions.MediaFile file = null;
if (actionSheet == "Chụp ảnh")
{
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
{
await DisplayAlert("Máy ảnh", "Máy ảnh không khả dụng", "Đóng");
gridLoading.IsVisible = false;
return;
}
PermissionStatus cameraStatus = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Camera);
if (cameraStatus != PermissionStatus.Granted)
{
if (await CrossPermissions.Current.ShouldShowRequestPermissionRationaleAsync(Permission.Camera))
{
await DisplayAlert("Quyền truy cập máy ảnh", "Sim ,ere cần truy cập vào máy ảnh để chụp hình cho ảnh đại diện", "Đồng ý");
}
if (Device.RuntimePlatform == Device.iOS)
{
cameraStatus = await PermissionHelper.CheckPermissions(Permission.Camera, "Quyền truy cập máy ảnh", "Sim Here cần truy cập vào máy ảnh để chụp hình cho ảnh đại diện");
}
else
{
var results = await CrossPermissions.Current.RequestPermissionsAsync(Permission.Camera);
cameraStatus = results[Permission.Camera];
}
}
if (cameraStatus == PermissionStatus.Granted)
{
gridLoading.IsVisible = true;
file = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions
{
SaveToAlbum = false,
PhotoSize = Plugin.Media.Abstractions.PhotoSize.MaxWidthHeight,
MaxWidthHeight = 300,
});
}
}
else if (actionSheet == "Chọn ảnh")
{
await CrossMedia.Current.Initialize();
Permission pickPhotoStatus = Permission.Storage;
if (Device.RuntimePlatform == Device.iOS)
{
pickPhotoStatus = Permission.Photos;
}
PermissionStatus photoPermisstionStatue = await CrossPermissions.Current.CheckPermissionStatusAsync(pickPhotoStatus);
if (photoPermisstionStatue != PermissionStatus.Granted)
{
if (await CrossPermissions.Current.ShouldShowRequestPermissionRationaleAsync(pickPhotoStatus))
{
await DisplayAlert("Quyền truy cập hình ảnh", "Sim Here cần truy cập vào thư viện hình ảnh để đặt anh đại ", "Đồng ý");
}
if (Device.RuntimePlatform == Device.iOS)
{
photoPermisstionStatue = await PermissionHelper.CheckPermissions(pickPhotoStatus, "Quyền truy cập hình ảnh", "Sim Here muốn truy cập vào thư viện hình ảnh của bạn để lấy hình ảnh đặt làm ảnh đại diện cho bạn.");
}
else
{
var results = await CrossPermissions.Current.RequestPermissionsAsync(pickPhotoStatus);
photoPermisstionStatue = results[pickPhotoStatus];
}
}
if (photoPermisstionStatue == PermissionStatus.Granted)
{
gridLoading.IsVisible = true;
file = await CrossMedia.Current.PickPhotoAsync(new Plugin.Media.Abstractions.PickMediaOptions()
{
MaxWidthHeight = 300,
PhotoSize = Plugin.Media.Abstractions.PhotoSize.MaxWidthHeight
});
}
}
else
{
gridLoading.IsVisible = false;
}
if (file == null)
{
gridLoading.IsVisible = false;
return;
}
var client = BsdHttpClient.Instance();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", UserLogged.AccessToken);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
MultipartFormDataContent form = new MultipartFormDataContent();
var stream = file.GetStream();
var content = new StreamContent(stream);
content.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "files",
FileName = "test.jpg"
};
form.Add(content);
try
{
HttpResponseMessage response = await(client.PostAsync("api/user/changeavatar", form));
string body = await response.Content.ReadAsStringAsync();
ApiResponse apiResponse = JsonConvert.DeserializeObject <ApiResponse>(body);
if (apiResponse.IsSuccess)
{
string newFileName = apiResponse.Content.ToString();
ImageSource newImageSource = ImageSource.FromStream(() => file.GetStream());
SetAvatar(newImageSource);
TrackProfileChange.AvatarHasChanged = true;
UserLogged.AvatarUrl = AppConfig.API_IP + "Upload/Avatar/" + newFileName;
XFToast.ShortMessage("Cập nhật thành cộng");
gridLoading.IsVisible = false;
}
else
{
await DisplayAlert("", "Không thể cập nhật ảnh đại diện", "Đóng");
gridLoading.IsVisible = false;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
gridLoading.IsVisible = false;
}
}
public async void _bothButtons(bool isTakeClicked)
{
Plugin.Media.Abstractions.MediaFile file = null;
//var file = (Plugin.Media.Abstractions.IMedia)null;
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsPickPhotoSupported || !CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
{
if (isTakeClicked == false)
{
Console.WriteLine("No Gallery", ":( No gallery available.", "OK");
}
else
{
Console.WriteLine("No Camera", ":( No camera available.", "OK");
}
return;
}
if (isTakeClicked == true)
{
// Launch camera
//progress.Indeterminate = true;
//progress.SetCancelable(false);
//progress.SetProgressStyle(Android.App.ProgressDialogStyle.Spinner);
//progress.SetTitle("Please wait...");
//progress.Show();
file = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions
{
Directory = "temp",
// CompressionQuality = 25,
SaveToAlbum = false
});
}
else if (isTakeClicked == false)
{
// Choose from gallery
file = await CrossMedia.Current.PickPhotoAsync(new Plugin.Media.Abstractions.PickMediaOptions
{
// CompressionQuality = 25
});
}
if (file == null)
{
//progress.Dismiss();
return;
}
string filePath = file.Path;
file.Dispose();
var TakePhoto = new Android.Content.Intent(this, typeof(TakePhotoActivity));
TakePhoto.PutExtra("imageLocation", filePath);
StartActivity(TakePhoto);
}
/// <summary>
/// Adds an icon from storage
/// </summary>
async void AddIconStored()
{
await Xamarin.Forms.Application.Current.MainPage.Navigation.PopAllPopupAsync();
await Plugin.Media.CrossMedia.Current.Initialize();
var status = await Plugin.Permissions.CrossPermissions.Current.CheckPermissionStatusAsync(Plugin.Permissions.Abstractions.Permission.Photos);
if (status != Plugin.Permissions.Abstractions.PermissionStatus.Granted)
{
if (await Plugin.Permissions.CrossPermissions.Current.ShouldShowRequestPermissionRationaleAsync(Plugin.Permissions.Abstractions.Permission.Photos))
{
await Acr.UserDialogs.UserDialogs.Instance.AlertAsync("Need access to photos to make icon");
}
var results = await Plugin.Permissions.CrossPermissions.Current.RequestPermissionsAsync(new[] { Plugin.Permissions.Abstractions.Permission.Photos });
status = results[Plugin.Permissions.Abstractions.Permission.Photos];
}
if (status == Plugin.Permissions.Abstractions.PermissionStatus.Granted)
{
var userInput = await Acr.UserDialogs.UserDialogs.Instance.PromptAsync("Name the icon to add");
if (userInput == null || string.IsNullOrWhiteSpace(userInput.Text))
{
return;
}
Plugin.Media.Abstractions.MediaFile file = await Plugin.Media.CrossMedia.Current.PickPhotoAsync(new Plugin.Media.Abstractions.PickMediaOptions
{
CustomPhotoSize = 500,
CompressionQuality = 80,
RotateImage = true,
});
if (file == null || file.Path == null)
{
return;
}
if (System.IO.File.Exists(@file.Path))
{
byte[] imageArray = null;
//if (Device.RuntimePlatform == Device.Android)
//{
// imageArray = DependencyService.Get<InterfaceBitmapResize>().RotateImage(@file.Path);
//}
//else
//{
imageArray = System.IO.File.ReadAllBytes(@file.Path);
//}
string base64ImageRepresentation = System.Convert.ToBase64String(imageArray);
file.Dispose();
Storage.CommunicationIcon dynamicIcon = new Storage.CommunicationIcon()
{
Tag = IconRoles.GetRoleInt(IconRoles.Role.Communication),
Text = userInput.Text,
Local = false,
IsStoredInFolder = false,
FolderContainingIcon = "",
Base64 = base64ImageRepresentation,
Scale = 1f,
X = -1,
Y = -1
};
IconImage testImage = null;
try
{
testImage = App.ImageBuilderInstance.BuildCommunicationIconDynamic(icon: dynamicIcon);
}
catch
{
return;
}
SaveCommunicationIconEvent(testImage);
}
}
else if (status != Plugin.Permissions.Abstractions.PermissionStatus.Unknown)
{
await Acr.UserDialogs.UserDialogs.Instance.AlertAsync("Can not continue, try again");
}
}
//
async void setupFillData(Plugin.Media.Abstractions.MediaFile passImage)
{
//Get the transferred image to the image box
imgImage.Source = ImageSource.FromStream(() => { return(passImage.GetStream()); });
//"Invisible" Operations: Set like status (discrete & not viewable) and get location (discrete but Viewable)
//Like status operation already performed
//Get the GeoLocation in Variables
try
{
var geoRequest = new GeolocationRequest(GeolocationAccuracy.Medium);
var geoLocation = await Geolocation.GetLocationAsync(geoRequest);
//if it's not null we got your location
if (geoLocation != null)
{
pictureData.location = geoLocation;
// await DisplayAlert("Location achieved", "Your Location is: " + pictureData.location.ToString(), "OK");
}
}
//Else we don't have your location and we are substituting with temporary locations
catch (FeatureNotSupportedException fnsEX)
{
//Not supported on device
await DisplayAlert("Error: GPS Support", "GPS is not supported on this device", "OK");
// pictureData.location = null;
}
catch (FeatureNotEnabledException fneEX)
{
//Not enabled on device
await DisplayAlert("Error: GPS Enabled/Disabled", "GPS is not enabled on this device", "OK");
// pictureData.location = null;
}
catch (PermissionException pEX)
{
//Permission exception
await DisplayAlert("Error: GPS Permission", "GPS permissions are not accepted on this device", "OK");
// pictureData.location = null;
}
catch (Exception ex)
{
//couldn't get location
await DisplayAlert("Error: GPS Functionality", "Could not get location", "OK");
// pictureData.location = null;
}
//Set Date and Time
pictureData.dateTime = DateTime.Now;
//get date data (read only)
datePickDate.Date = pictureData.dateTime.Date;
//get time data (read only)
timePickTime.Time = pictureData.dateTime.TimeOfDay;
//display location time
if (pictureData.location == null)
{
entLocation.Text = "No Location";
}
else
{
entLocation.Text = pictureData.location.ToString();
}
//Start working the spinnner
//Populate the spinner
//spinner = spinnerTB.LoadAvailableTags(pictureData.tags);
spinner.ItemsSource = jsonTB.GetTags();
//var picker = new Picker { Title = "Select a monkey", TitleColor = Color.Red };
//picker.SetBinding(Picker.ItemsSourceProperty, "Monkeys");
//picker.ItemDisplayBinding = new Binding("Name");
//spinner function
spinner.SelectedIndexChanged += (sender, args) =>
{
if (spinner.SelectedIndex != -1)
{
}
};
//Add Tags Field to add tags
var entCellTags = new EntryCell {
Label = "Tags: "
};
//Add a save button to save the picture with the data
var save = new Button {
Text = "Save Picture",
};
}
async void SelectAttachFile(string fromWhere, string type)
{
Plugin.Media.Abstractions.MediaFile file = null;
if (type == "image")
{
if (fromWhere == "library")
{
file = await CrossMedia.Current.PickPhotoAsync();
}
else if (fromWhere == "camera")
{
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsPickPhotoSupported)
{
return;
}
file = await CrossMedia.Current.TakePhotoAsync(new Plugin.Media.Abstractions.StoreCameraMediaOptions
{
Directory = "Drop",
Name = "Image_" + DateTime.Now.ToString("dd-mm-yy_hh-mm-ss") + ".png"
});
}
if (file == null)
{
return;
}
while (System.IO.File.ReadAllBytes(file.Path).Length == 0)
{
System.Threading.Thread.Sleep(1);
}
var fileBytes = System.IO.File.ReadAllBytes(file.Path);
var fileName = "Image_" + DateTime.Now.ToString("dd-mm-yy_hh-mm-ss") + ".png";
ItemModel.Image = new MediaFile(fileName, fileBytes);
btnDropImageSymbol.SetImageResource(Resource.Drawable.icon_image_sel);
}
else if (type == "video")
{
if (fromWhere == "library")
{
file = await CrossMedia.Current.PickVideoAsync();
}
else if (fromWhere == "camera")
{
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsPickPhotoSupported)
{
return;
}
file = await CrossMedia.Current.TakeVideoAsync(new Plugin.Media.Abstractions.StoreVideoOptions
{
Directory = "Drop",
Quality = Plugin.Media.Abstractions.VideoQuality.Medium,
Name = "Video_" + DateTime.Now.ToString("dd-mm-yy_hh-mm-ss") + ".mp4",
});
}
if (file == null)
{
return;
}
byte[] fileBytes1;
using (var memoryStream = new MemoryStream())
{
file.GetStream().CopyTo(memoryStream);
fileBytes1 = memoryStream.ToArray();
}
var fileName = "Video_" + DateTime.Now.ToString("dd-mm-yy_hh-mm-ss") + ".mp4";
ItemModel.Video = new MediaFile(fileName, fileBytes1);
btnDropVideoSymbol.SetImageResource(Resource.Drawable.icon_video_sel);
}
}
public static byte[] GetByteFromMediaFile(Plugin.Media.Abstractions.MediaFile file)
{
return(File.ReadAllBytes(file.Path));
}
private async Task MakeRequest(Plugin.Media.Abstractions.MediaFile myFile)
{
IsLoading = true;
ApiKeyServiceClientCredentials mykey = new ApiKeyServiceClientCredentials(SubscriptionKey);
var visionApiClient = new ComputerVisionClient(mykey);
//visionApiClient.AzureRegion = AzureRegions.Northeurope;
var recognizedResult = await visionApiClient.RecognizePrintedTextAsync(false, "https://b.zmtcdn.com/data/menus/804/17883804/ccb6c1fbcc945d2824e9f5508cda9098.jpg");
//var recognizedResult = await visionApiClient.RecognizePrintedTextInStreamAsync(false, myFile.GetStream);
List <Model.MenuItem> menuItems = new List <Model.MenuItem>();
foreach (var region in recognizedResult.Regions)
{
foreach (var line in region.Lines)
{
string item1 = "";
foreach (var word in line.Words)
{
item1 += word;
}
menuItems.Add(new Model.MenuItem()
{
Title = item1
});
}
}
IsLoading = false;
await App.NavigationService.PushAsync(new MenuListingPage());
/*var client = new HttpClient();
* var queryString = HttpUtility.ParseQueryString(string.Empty);
*
* // Request headers
* client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", SubscriptionKey);
*
* // Request parameters
* string queryparam = "mode=printed";
* var uri = "https://northeurope.api.cognitive.microsoft.com/vision/v1.0/OCR?" + queryparam;
*
* HttpResponseMessage response;*/
/* //to use for sending files
* using (var memoryStream = new System.IO.MemoryStream())
* {
* myFile.GetStream().CopyTo(memoryStream);
* myFile.Dispose();
* using (var content = new ByteArrayContent(memoryStream.ToArray()))
* {
* content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
* response = await client.PostAsync(ComputerVisionApiURL, content);
* }
* }
*//*
* string urlbody = "{'url':'https://i.pinimg.com/originals/bc/f4/c2/bcf4c20c441c9b67ac43ff399992adf7.jpg'}";
* using (var content = new StringContent(urlbody))
* {
* content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
* response = await client.PostAsync(ComputerVisionApiURL, content);
* if (response.StatusCode == System.Net.HttpStatusCode.Accepted)
* {
* var test = new List<string>(response.Headers.GetValues("Operation-Location"));
* var test2 = test[0];
* response = await client.PostAsync(test2, new StringContent(""));
* string contentString = await response.Content.ReadAsStringAsync();
* }
* else
* { string contentString = await response.Content.ReadAsStringAsync(); }
* }*/
}
private async void btnTakePhoto_Clicked(object sender, EventArgs e)
{
await Plugin.Media.CrossMedia.Current.Initialize();
var cameraStatus = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Camera);
var storageStatus = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Storage);
if (cameraStatus != PermissionStatus.Granted || storageStatus != PermissionStatus.Granted)
{
var results = await CrossPermissions.Current.RequestPermissionsAsync(new[] { Permission.Camera, Permission.Storage });
cameraStatus = results[Permission.Camera];
storageStatus = results[Permission.Storage];
}
if (cameraStatus == PermissionStatus.Granted && storageStatus == PermissionStatus.Granted)
{
if (Plugin.Media.CrossMedia.Current.IsCameraAvailable)
{
Plugin.Media.Abstractions.MediaFile curPhoto = await Plugin.Media.CrossMedia.Current.TakePhotoAsync(
new Plugin.Media.Abstractions.StoreCameraMediaOptions()
{
AllowCropping = false,
Directory = "__temp__"
});
if (curPhoto != null)
{
szImageName = Path.GetFileName(curPhoto.Path);
curProjectSql.szTempProjectPath = Path.GetDirectoryName(curPhoto.Path);
string szFullImageName = Path.Combine(curProjectSql.szProjectPath, Path.GetFileName(curPhoto.Path));
File.Copy(curPhoto.Path, szFullImageName);
string szDelPath = Path.GetDirectoryName(curPhoto.Path);
string[] files = Directory.GetFiles(szDelPath, "*.*");
try
{
foreach (var file in files)
{
File.Delete(file);
}
}
catch (Exception)
{
}
var memoryStream = new MemoryStream();
using (var fileStream = new FileStream(szFullImageName, FileMode.Open, FileAccess.Read))
{
fileStream.CopyTo(memoryStream);
}
memoryStream.Position = 0;
PhotoImage.Source = ImageSource.FromStream(() => memoryStream);
ShowMetadata();
}
}
else
{
await DisplayAlert("No camera available", "Unable to take photos.", "OK");
}
}
else
{
await DisplayAlert("Permissions Denied", "Unable to take photos.", "OK");
//On iOS you may want to send your user to the settings screen.
//CrossPermissions.Current.OpenAppSettings();
}
}
public PictureChoosenEventArgs(Plugin.Media.Abstractions.MediaFile file)
{
File = file;
}
public FlujoViewModel(User usuario)
{
Globals.FlujoViewModelInstance = this;
Usuario = usuario;
MultiMediaPickerService = Globals.MultiMediaPickerService;
RepositoryService = Globals.RepositoryService;
AddPhotoCommand = new Command((obj) =>
{
Plugin.Media.Abstractions.MediaFile mediaFile = obj as Plugin.Media.Abstractions.MediaFile;
if (mediaFile == null)
{
return;
}
if (Media == null)
{
Media = new ObservableCollection <XGaleryPhotos.Models.MediaFile>();
}
Media.Add(new MediaFile()
{
Id = Guid.NewGuid().ToString(),
Type = MediaFileType.Image,
Path = mediaFile.Path,
PreviewPath = mediaFile.Path
}
);
});
BuscarFlujoCommand = new Command((obj) =>
{
string flujoNro = obj as string;
Flujo = RepositoryService.GetFlujoByNro(flujoNro);
});
EnviarOnBaseCommand = new Command((obj) =>
{
Globals.RepositoryService.UpdateFotos(Flujo, Usuario.UserName);
});
PhotoTappedCommand = new Command((obj) =>
{
var mediaSelected = obj as XGaleryPhotos.Models.MediaFile;
Globals.RepositoryService.AddMediaFile(mediaSelected);
Globals.PhotoDisplayPageInstance.ResetSource();
Globals.NavegacionPageInstance.PushAsync(Globals.PhotoDisplayPageInstance);
});
SelectImagesCommand = new Command(async(obj) =>
{
var hasPermission = await CheckPermissionsAsync();
if (hasPermission)
{
if (Media == null)
{
Media = new ObservableCollection <XGaleryPhotos.Models.MediaFile>();
}
await MultiMediaPickerService.PickPhotosAsync();
}
});
MultiMediaPickerService.OnMediaPicked += (s, a) =>
{
Device.BeginInvokeOnMainThread(() =>
{
Media.Add(a);
});
};
}
