public async Task <string> UploadUserAvatarAsync(PickedImage pickedImage, CancellationToken cancellationToken = default(CancellationToken)) =>
await Task.Run(async() => {
string userAvatar = string.Empty;
string url = BaseSingleton <GlobalSetting> .Instance.RestEndpoints.IdentityEndpoints.UploadUserAvatarEndpoint;
string accessToken = BaseSingleton <GlobalSetting> .Instance.UserProfile.AccesToken;
try {
User user = await _requestProvider.PostFormDataAsync <User, PickedImage>(url, pickedImage, accessToken);
if (user != null)
{
userAvatar = user.AvatarUrl;
BaseSingleton <GlobalSetting> .Instance.UserProfile.AvatarUrl = user.AvatarUrl;
BaseSingleton <GlobalSetting> .Instance.UserProfile.SaveChanges();
}
}
catch (ConnectivityException ex) {
throw ex;
}
catch (ServiceAuthenticationException ex) {
await this.LogOutAsync();
throw ex;
}
catch (HttpRequestExceptionEx ex) {
throw ex;
}
catch (Exception ex) {
Debug.WriteLine($"ERROR:{ex.Message}");
Debugger.Break();
}
return(userAvatar);
}, cancellationToken);
public async Task <PickedImage> BuildPickedImageAsync()
{
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsPickPhotoSupported)
{
return(null);
}
PickedImage pickedImage = null;
using (var file = await CrossMedia.Current.PickPhotoAsync(new PickMediaOptions {
PhotoSize = PhotoSize.Medium, CompressionQuality = 90
})) {
if (file == null)
{
return(null);
}
try {
Stream stream = file.GetStream();
pickedImage = new PickedImage {
Name = Path.GetFileName(file.Path),
Body = await ParseStreamToBytesAsync(stream)
};
}
catch (Exception) {
pickedImage = null;
}
}
return(pickedImage);
}
private async void libraryImageSelected(LibraryImageSelectedMessage message)
{
if (message.ReceiverID == _receiverID)
{
var result = await Task <IImage> .Factory.StartNew(() =>
{
IImage image = null;
try
{
if (message.Path != null)
{
var path = message.Path;
var file = new MediaFile(path, () => File.OpenRead(path));
var rawImage = getScaledAndRotatedImage(file, Constants.MaxPixelDimensionOfImages);
//Initialize picked image
image = new PickedImage
{
Name = Path.GetFileName(path),
RawImage = rawImage
};
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
return(image);
});
_selectImageCompletion.TrySetResult(result);
}
}
public async Task <PickedImage> BuildPickedImageAsync(MediaFile mediaFile)
{
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsPickPhotoSupported)
{
return(null);
}
PickedImage pickedImage = null;
if (mediaFile == null)
{
return(null);
}
try {
Stream stream = mediaFile.GetStream();
pickedImage = new PickedImage {
Name = Path.GetFileName(mediaFile.Path),
Body = await ParseStreamToBytesAsync(stream)
};
}
catch (Exception) {
pickedImage = null;
}
return(pickedImage);
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent intent)
{
if (requestCode == PickImageId)
{
if ((resultCode == Result.Ok) && (intent != null))
{
Android.Net.Uri uri = intent.Data;
System.IO.Stream stream = ContentResolver.OpenInputStream(uri);
PickedImage pi = new PickedImage();
pi.DecodedPath = uri.Path;
pi.EncodedPath = uri.EncodedPath;
pi.DataStream = stream;
pi.FilePath = GetRealPathFromMediaStoreImageURI(uri);
// Set the Stream as the completion of the Task
PickImageTaskCompletionSource.SetResult(pi);
}
else
{
PickImageTaskCompletionSource.SetResult(null);
}
}
base.OnActivityResult(requestCode, resultCode, intent);
}
public FileDTO BuidFileDTO(PickedImage pickedImage)
{
FileDTO file = null;
if (pickedImage != null)
{
file = new FileDTO()
{
Base64 = pickedImage.DataBase64,
Name = string.Format("{0}.{1}", Guid.NewGuid(), ProfileMediaService.PNG_IMAGE_FORMAT)
};
}
return(file);
}
public Task <IImage> getImageFromMediaFile(MediaFile file)
{
return(Task <IImage> .Factory.StartNew(() =>
{
var rawImage = getScaledAndRotatedImage(file, Constants.MaxPixelDimensionOfImages);
//Initialize picked image
var image = new PickedImage
{
Name = Path.GetFileName(file.Path),
RawImage = rawImage
};
return image;
}));
}
public Task <PickedImage> BuildPickedImageAsync(MediaFile mediaFile) =>
Task <PickedImage> .Run(async() => {
PickedImage pickedImage = null;
try {
pickedImage = new PickedImage();
pickedImage.DataBase64 = await ParseStreamToBase64(mediaFile.GetStream());
pickedImage.Name = Path.GetFileName(mediaFile.Path);
}
catch (Exception exc) {
Crashes.TrackError(exc);
pickedImage = null;
}
return(pickedImage);
});
private async void cameraImageSelected(CameraImageSelectedMessage message)
{
if (message.ReceiverID == _receiverID)
{
var result = await Task <IImage> .Factory.StartNew(() =>
{
IImage image = null;
if (message.Image != null)
{
image = new PickedImage
{
Name = Guid.NewGuid() + ".jpg",
RawImage = message.Image.GetRawBytes(Bitmap.CompressFormat.Jpeg)
};
}
return(image);
});
_selectImageCompletion.TrySetResult(result);
}
}
private async void btnPickImg_Clicked(object sender, EventArgs e)
{
if (null != MobileGlobals.PhotoPickerProviderInst)
{
PickedImage pi = await MobileGlobals.PhotoPickerProviderInst.GetImageStreamAsync();
if (pi != null)
{
if (null != MobileGlobals.SmsProviderInst)
{
pduData = MobileGlobals.SmsProviderInst.GetMMSPduData(txtAddress.Text, pi.FilePath, "This is a test message! Respond to let me know if you got it and whether you see the image.");
if (null != pduData)
{
MobileGlobals.SmsProviderInst.SendMMSPduData(pduData);
}
else
{// PDU shouldn't be null
throw new Exception("PDU Data is NULL!");
}
}
}
}
}
private async void AnalysePhotoAsync()
{
Guid busyKey = Guid.NewGuid();
SetBusy(busyKey, true);
PickedImage targetImage = null;
ResetCancellationTokenSource(ref _analysePhotoCancellationTokenSource);
CancellationTokenSource cancellationTokenSource = _analysePhotoCancellationTokenSource;
try {
using (var file = await _pickMediaService.TakePhotoAsync()) {
if (file != null)
{
List <string> results = await _visionService.AnalyzeImageForText(file);
if (results != null && results.Any())
{
List <string> parsedResult = results.ParseVisionResult();
targetImage = await _pickMediaService.BuildPickedImageAsync(file);
if (targetImage != null)
{
FormDataContent formDataContent = new FormDataContent {
Content = parsedResult,
MediaContent = targetImage
};
List <DriveAuto> driveAutoDetails =
await _driveAutoService.SearchDriveAutoByCognitiveAsync(formDataContent, cancellationTokenSource.Token);
if (driveAutoDetails != null)
{
DriveAutoDetails = driveAutoDetails.ToObservableCollection();
HasResult = true;
}
else
{
HasResult = false;
ErrorMessage = string.Empty;
}
}
}
else
{
HasResult = false;
ErrorMessage = ResourceLoader.GetString(nameof(AppStrings.TryMore)).Value;
}
file.Dispose();
}
}
}
catch (Exception ex) {
Debug.WriteLine($"ERROR: -{ex.Message}");
Debugger.Break();
try {
HttpRequestExceptionResult httpRequestExceptionResult = JsonConvert.DeserializeObject <HttpRequestExceptionResult>(ex.Message);
HasResult = false;
ErrorMessage = httpRequestExceptionResult.Message;
}
catch (Exception exc) {
Debug.WriteLine($"ERROR: -{exc.Message}");
Debugger.Break();
BackCommand.Execute(null);
}
}
SetBusy(busyKey, false);
if (targetImage == null)
{
BackCommand.Execute(null);
}
}
