public Photo(string filename)
{
Filename = filename;
// Get and set picture orienation
ExifInterface exif = new ExifInterface(Filename);
mOrientation = exif.GetAttributeInt(ExifInterface.TagOrientation, (int)PhotoOrienation.Normal);
}
public override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult (requestCode, resultCode, data);
if (resultCode == Result.Ok) {
// Make it available in the gallery
// Intent mediaScanIntent = new Intent (Intent.ActionMediaScannerScanFile);
// Android.Net.Uri contentUri = Android.Net.Uri.FromFile (file);
// mediaScanIntent.SetData (contentUri);
//
// Activity.SendBroadcast (mediaScanIntent);
//
AttendancePhoto attPhoto = new AttendancePhoto () {
photoPath = file.ToString (),
stamp = DateTime.Now,
subType = currentPhotoSubTypes[spnPhotoSubTypes.SelectedItemPosition].id
};
//Latitude and Longitude
ExifInterface exif = new ExifInterface (attPhoto.photoPath);
float[] lat_long = new float[2];
if (exif.GetLatLong (lat_long)) {
attPhoto.latitude = lat_long [0];
attPhoto.longitude = lat_long [1];
}
newAttendancePhotos.Add (attPhoto);
AttendancePhotoManager.SetCurrentAttendancePhotos (newAttendancePhotos);
RefreshPhotoList ();
}
// Dispose of the Java side bitmap.
GC.Collect();
}
static int? GetRotation(string filePath)
{
try
{
ExifInterface ei = new ExifInterface(filePath);
var orientation = (MediaOrientation)ei.GetAttributeInt(ExifInterface.TagOrientation, (int)MediaOrientation.Normal);
switch (orientation)
{
case MediaOrientation.Rotate90:
return 90;
case MediaOrientation.Rotate180:
return 180;
case MediaOrientation.Rotate270:
return 270;
default:
return null;
}
}
catch (Exception ex)
{
//ex.Report();
return null;
}
}
public static Bitmap GetAndRotateBitmap(string fileName)
{
Bitmap bitmap = BitmapFactory.DecodeFile(fileName);
// Images are being saved in landscape, so rotate them back to portrait if they were taken in portrait
// See https://forums.xamarin.com/discussion/5409/photo-being-saved-in-landscape-not-portrait
// See http://developer.android.com/reference/android/media/ExifInterface.html
using (Matrix mtx = new Matrix())
{
if (Android.OS.Build.Product.Contains("Emulator"))
{
mtx.PreRotate(90);
}
else
{
ExifInterface exif = new ExifInterface(fileName);
var orientation = (Orientation)exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Normal);
//TODO : handle FlipHorizontal, FlipVertical, Transpose and Transverse
switch (orientation)
{
case Orientation.Rotate90:
mtx.PreRotate(90);
break;
case Orientation.Rotate180:
mtx.PreRotate(180);
break;
case Orientation.Rotate270:
mtx.PreRotate(270);
break;
case Orientation.Normal:
// Normal, do nothing
break;
default:
break;
}
}
if (mtx != null)
bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, mtx, false);
}
return bitmap;
}
public override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult (requestCode, resultCode, data);
if (resultCode == Result.Ok) {
bIsPhotoMake = false;
// Make it available in the gallery
Intent mediaScanIntent = new Intent (Intent.ActionMediaScannerScanFile);
Android.Net.Uri contentUri = Android.Net.Uri.FromFile (file);
mediaScanIntent.SetData (contentUri);
Activity.SendBroadcast (mediaScanIntent);
ExifInterface exif = new ExifInterface (file.ToString ());
text.Text += String.Format(@"TagGpsLatitude : {0} \n", exif.GetAttribute (ExifInterface.TagGpsLatitude));
text.Text += String.Format(@"TagGpsLongitude : {0} \n", exif.GetAttribute (ExifInterface.TagGpsLongitude));
text.Text += String.Format(@"TagGpsDatestamp : {0} \n", exif.GetAttribute (ExifInterface.TagGpsDatestamp));
text.Text += String.Format(@"TagIso : {0} \n", exif.GetAttribute (ExifInterface.TagIso));
text.Text += String.Format(@"TagDatetime : {0} \n", exif.GetAttribute (ExifInterface.TagDatetime));
AttendancePhoto attPhoto = new AttendancePhoto () { id = -1, photoPath = file.ToString ()};
DateTime dtStamp;
if (DateTime.TryParse (exif.GetAttribute (ExifInterface.TagDatetime), out dtStamp)){
attPhoto.stamp = dtStamp;
};
float gps;
if (float.TryParse (exif.GetAttribute (ExifInterface.TagGpsLatitude), out gps)){
attPhoto.latitude = gps;
};
if (float.TryParse (exif.GetAttribute (ExifInterface.TagGpsLongitude), out gps)){
attPhoto.longitude = gps;
};
attPhoto.latitude = convertToDegree (exif.GetAttribute (ExifInterface.TagGpsLatitude));
attPhoto.longitude = convertToDegree (exif.GetAttribute (ExifInterface.TagGpsLongitude));
newAttendancePhotos.Add (attPhoto);
}
// Dispose of the Java side bitmap.
GC.Collect();
}
public static Bitmap LoadAndResizeBitmap (this string fileName, int width, int height)
{
ExifInterface exif = new ExifInterface (fileName);
int exifOrientation = exif.GetAttributeInt (
ExifInterface.TagOrientation,
(int)Android.Media.Orientation.Normal);
int rotate = 0;
switch (exifOrientation) {
case (int) Android.Media.Orientation.Rotate90:
rotate = 90;
break;
case (int) Android.Media.Orientation.Rotate180:
rotate = 180;
break;
case (int) Android.Media.Orientation.Rotate270:
rotate = 270;
break;
}
Bitmap bitmap = BitmapFactory.DecodeFile (fileName);
int w = bitmap.Width;
int h = bitmap.Height;
// Setting pre rotate
Matrix mtx = new Matrix ();
mtx.PreRotate (rotate);
// Rotating Bitmap & convert to ARGB_8888, required by tess
bitmap = Bitmap.CreateBitmap (bitmap, 0, 0, w, h, mtx, false);
bitmap = bitmap.Copy (Bitmap.Config.Argb8888, true);
return bitmap;
}
public static Bitmap RotateImageIfNeeded(Bitmap bitmap, string path)
{
ExifInterface ei = new ExifInterface(path);
int orientation = ei.GetAttributeInt(ExifInterface.TagOrientation, (int)Android.Media.Orientation.Undefined);
Bitmap returnBitmap = bitmap;
switch (orientation)
{
case (int)Android.Media.Orientation.Rotate90:
returnBitmap = RotateImage(bitmap, 90);
break;
case (int)Android.Media.Orientation.Rotate180:
returnBitmap = RotateImage(bitmap, 180);
break;
case (int)Android.Media.Orientation.Rotate270:
returnBitmap = RotateImage(bitmap, 270);
break;
default:
returnBitmap = RotateImage(bitmap, 270);
break;
}
return returnBitmap;
}
public override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult (requestCode, resultCode, data);
if (resultCode == Result.Ok) {
// Make it available in the gallery
Intent mediaScanIntent = new Intent (Intent.ActionMediaScannerScanFile);
Android.Net.Uri contentUri = Android.Net.Uri.FromFile (file);
mediaScanIntent.SetData (contentUri);
Activity.SendBroadcast (mediaScanIntent);
ExifInterface exif = new ExifInterface (file.ToString ());
text.Text += String.Format(@"TagGpsLatitude : {0} \n", exif.GetAttribute (ExifInterface.TagGpsLatitude));
text.Text += String.Format(@"TagGpsLongitude : {0} \n", exif.GetAttribute (ExifInterface.TagGpsLongitude));
text.Text += String.Format(@"TagGpsDatestamp : {0} \n", exif.GetAttribute (ExifInterface.TagGpsDatestamp));
text.Text += String.Format(@"TagIso : {0} \n", exif.GetAttribute (ExifInterface.TagIso));
text.Text += String.Format(@"TagDatetime : {0} \n", exif.GetAttribute (ExifInterface.TagDatetime));
}
// Dispose of the Java side bitmap.
GC.Collect();
}
public static int GetExifRotationDegrees(this string filePath)
{
int rotation = 0;
var exifInt = new ExifInterface(filePath);
int exifRotation = exifInt.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Normal);
switch (exifRotation)
{
case (int) Orientation.Rotate270:
rotation = 270;
break;
case (int) Orientation.Rotate180:
rotation = 180;
break;
case (int) Orientation.Rotate90:
rotation = 90;
break;
default:
return 0;
}
return rotation;
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
RequestWindowFeature(Android.Views.WindowFeatures.NoTitle);
this.RequestedOrientation = Android.Content.PM.ScreenOrientation.Portrait;
SetContentView(Resource.Layout.cropimage);
imageView = FindViewById<CropImageView>(Resource.Id.image);
showStorageToast(this);
Bundle extras = Intent.Extras;
if (extras != null)
{
imagePath = extras.GetString("image-path");
saveUri = getImageUri(imagePath);
if (extras.GetString(MediaStore.ExtraOutput) != null)
{
saveUri = getImageUri(extras.GetString(MediaStore.ExtraOutput));
}
bitmap = getBitmap(imagePath);
aspectX = extras.GetInt("aspectX");
aspectY = extras.GetInt("aspectY");
outputX = extras.GetInt("outputX");
outputY = extras.GetInt("outputY");
scale = extras.GetBoolean("scale", true);
scaleUp = extras.GetBoolean("scaleUpIfNeeded", true);
if (extras.GetString("outputFormat") != null)
{
outputFormat = Bitmap.CompressFormat.ValueOf(extras.GetString("outputFormat"));
}
}
if (bitmap == null)
{
Finish();
return;
}
Window.AddFlags(WindowManagerFlags.Fullscreen);
FindViewById<Button>(Resource.Id.discard).Click += (sender, e) => { SetResult(Result.Canceled); Finish(); };
FindViewById<Button>(Resource.Id.save).Click += (sender, e) => { onSaveClicked(); };
FindViewById<Button>(Resource.Id.rotateLeft).Click += (o, e) =>
{
bitmap = Util.rotateImage(bitmap, -90);
RotateBitmap rotateBitmap = new RotateBitmap(bitmap);
imageView.SetImageRotateBitmapResetBase(rotateBitmap, true);
addHighlightView();
};
FindViewById<Button>(Resource.Id.rotateRight).Click += (o, e) =>
{
bitmap = Util.rotateImage(bitmap, 90);
RotateBitmap rotateBitmap = new RotateBitmap(bitmap);
imageView.SetImageRotateBitmapResetBase(rotateBitmap, true);
addHighlightView();
};
ExifInterface exif = new ExifInterface(imagePath);
string orientation = exif.GetAttribute(ExifInterface.TagOrientation);
switch(orientation) {
case "6" : // portrait
bitmap = Util.rotateImage(bitmap, -90);
break;
case "1" : // landscape
break;
default :
bitmap = Util.rotateImage(bitmap, -90);
break;
}
imageView.SetImageBitmapResetBase(bitmap, true);
addHighlightView();
}
/// <summary>
/// Called after the user image is captured
/// Stores the image, displays it on the GUI, and submits it for facial recognition
/// </summary>
/// <param name="requestCode"></param>
/// <param name="resultCode"></param>
/// <param name="data"></param>
protected override async void OnActivityResult( int requestCode, Result resultCode, Intent data )
{
base.OnActivityResult( requestCode, resultCode, data );
// Make it available in the gallery
Intent mediaScanIntent = new Intent(Intent.ActionMediaScannerScanFile);
// Gets the image file
Android.Net.Uri contentUri = Android.Net.Uri.FromFile(App._file);
// Put image file into media database
mediaScanIntent.SetData( contentUri );
SendBroadcast( mediaScanIntent );
// Determine the dimensions to resize the image to
// Loading the full sized image will consume to much memory and cause the application to crash
int ImageHeight = Resources.DisplayMetrics.HeightPixels;
int ImageWidth = UserImageView.Height;
// Load the image
App.bitmap = App._file.Path.LoadAndResizeBitmap( ImageWidth, ImageHeight );
// Check that the image was loaded successfull
if (App.bitmap != null)
{
// Check the image orientation
ExifInterface exif = new ExifInterface( App._file.AbsoluteFile.ToString() );
int Orientation = Convert.ToInt32( exif.GetAttribute( ExifInterface.TagOrientation ) );
App.bitmap = BitmapHelpers.RotateBitmap( App.bitmap, Orientation );
// Set the bitmap to the image view
UserImageView.SetImageBitmap( App.bitmap );
// Submit the image for facial recognition matching
string recognizeResult = await RecognizeImage( App.bitmap );
// Remove the image data from memory
App.bitmap = null;
// Set the match name
MatchTextView.Text = recognizeResult;
// Get the match image from the name
string MatchImageURL;
CelebrityImage.TryGetValue( recognizeResult, out MatchImageURL );
if (MatchImageURL != null)
{
Bitmap CelebrityImageBitmap = BitmapHelpers.GetImageBitmapFromUrl( MatchImageURL );
MatchImageView.SetImageBitmap( CelebrityImageBitmap );
}
}
// Dispose of the Java side bitmap
GC.Collect();
}
protected override void OnCreate(Bundle bundle) {
RequestWindowFeature(WindowFeatures.NoTitle);
base.OnCreate(bundle);
this.SetContentView(Resource.Layout.SignaturePad);
SignaturePadOrientation actualOrientation = SignaturePadOrientation.Automatic;
this.currentConfig = new SignaturePadConfiguration();
this.currentConfig.LoadFromIntent(this.Intent);
var rootView = this.FindViewById<RelativeLayout>(Resource.Id.rootView);
this.signatureView = this.FindViewById<SignaturePadView>(Resource.Id.signatureView);
this.btnSave = this.FindViewById<Button>(Resource.Id.btnSave);
this.btnCancel = this.FindViewById<Button>(Resource.Id.btnCancel);
var cfg = currentConfig;
rootView.SetBackgroundColor(cfg.BackgroundColor.ToAndroidColor());
this.signatureView.BackgroundColor = cfg.SignatureBackgroundColor.ToAndroidColor();
this.signatureView.Caption.Text = cfg.CaptionText;
this.signatureView.Caption.SetTextColor(cfg.CaptionTextColor.ToAndroidColor());
this.signatureView.ClearLabel.Text = cfg.ClearText;
this.signatureView.ClearLabel.SetTextColor(cfg.ClearTextColor.ToAndroidColor());
this.signatureView.SignatureLineColor = cfg.SignatureLineColor.ToAndroidColor();
this.signatureView.SignaturePrompt.Text = cfg.PromptText;
this.signatureView.SignaturePrompt.SetTextColor(cfg.PromptTextColor.ToAndroidColor());
this.signatureView.StrokeColor = cfg.StrokeColor.ToAndroidColor();
this.signatureView.StrokeWidth = cfg.StrokeWidth;
this.btnSave.Text = cfg.SaveText;
this.btnCancel.Text = cfg.CancelText;
if (string.IsNullOrWhiteSpace(cfg.CancelText)) {
this.btnCancel.Visibility = ViewStates.Invisible;
}
var exif = new ExifInterface(cfg.BackgroundImage);
var orientation = exif.GetAttribute(ExifInterface.TagOrientation);
var width = exif.GetAttributeInt(ExifInterface.TagImageWidth, 100);
var height = exif.GetAttributeInt(ExifInterface.TagImageLength, 80);
switch (orientation) {
case "1": // landscape
case "3": // landscape
actualOrientation = SignaturePadOrientation.Landscape;
break;
case "8":
case "4":
case "6": // portrait
actualOrientation = SignaturePadOrientation.Portrait;
break;
case "0": //undefined
default:
if (width > height)
actualOrientation = SignaturePadOrientation.Landscape;
else
actualOrientation = SignaturePadOrientation.Portrait;
break;
}
switch (actualOrientation) {
case SignaturePadOrientation.Landscape:
this.RequestedOrientation = Android.Content.PM.ScreenOrientation.Landscape;
break;
case SignaturePadOrientation.Portrait:
this.RequestedOrientation = Android.Content.PM.ScreenOrientation.Portrait;
break;
}
this.signatureView.BackgroundImageView.LayoutParameters.Height = ViewGroup.LayoutParams.FillParent;
this.signatureView.BackgroundImageView.LayoutParameters.Width = ViewGroup.LayoutParams.FillParent;
this.signatureView.BackgroundImageView.ViewTreeObserver.GlobalLayout += (sender, e) => //also tried with _View
{
var newSize = new Size(this.signatureView.Width, this.signatureView.Height);
if (newSize.Width > 0 && !hasBackground) {
if (cfg.Points != null && cfg.Points.Count() > 0) {
var points = cfg.Points.Select(i => i.GetPointF()).ToArray();
this.signatureView.LoadPoints(points);
} else {
}
//Get a smaller image if needed (memory optimization)
var bm = LoadAndResizeBitmap(cfg.BackgroundImage, newSize);
if (bm != null) {
hasBackground = true;
switch (cfg.BackgroundImageSize) {
case SignaturePadBackgroundSize.Fill:
this.signatureView.BackgroundImageView.SetScaleType(ImageView.ScaleType.FitXy);
this.signatureView.BackgroundImageView.SetAdjustViewBounds(true);
break;
case SignaturePadBackgroundSize.Stretch:
this.signatureView.BackgroundImageView.SetScaleType(ImageView.ScaleType.FitXy);
break;
}
this.signatureView.BackgroundImageView.SetImageBitmap(bm);
}
}
};
}
protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
{
base.OnActivityResult(requestCode, resultCode, data);
if ((resultCode == Result.Ok) && (data != null))
{
if (requestCode == PickImageId)
{
Uri uri = data.Data;
Bitmap tempBitmap = BitmapFactory.DecodeFile(GetPathToImage(uri));
//resize
int newHeight = ConvertDptoPx(60);
int newWidth = (int) (((float) tempBitmap.Width) / ((float) tempBitmap.Height) * newHeight);
//scale
float scaleWidth = ((float) newWidth) / tempBitmap.Width;
float scaleHeight = ((float) newHeight) / tempBitmap.Height;
Matrix matrix = new Matrix();
matrix.PostScale(scaleWidth, scaleHeight);
//rotate
ExifInterface exif = new ExifInterface(GetPathToImage(uri));
int orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, 1);
switch (orientation)
{
case 3:
matrix.PostRotate(180);
break;
case 6:
matrix.PostRotate(90);
break;
case 8:
matrix.PostRotate(270);
break;
}
_bitmap = Bitmap.CreateBitmap(tempBitmap, 0, 0, tempBitmap.Width, tempBitmap.Height, matrix, false);
tempBitmap.Recycle();
_imageView.SetImageBitmap(_bitmap);
}
else if (requestCode == PickContactsId)
{
_participantsAdapter.Items.Clear();
string intentString = data.GetStringExtra("New participants");
if (intentString != string.Empty)
{
string[] contactStrings = intentString.Split('|');
for (int i = 0; i < contactStrings.Length; i++)
{
string[] contactAttr = contactStrings[i].Split(',');
_participantsAdapter.Items.Add(new ListItem(contactAttr[0], int.Parse(contactAttr[1]))); // 0 = naam, 1 = image
}
}
_participantsAdapter.NotifyDataSetChanged();
_participantsRecyclerView.LayoutParameters.Height = ConvertDptoPx(listItemHeight * _participantsAdapter.Items.Count);
_participantsRecyclerView.Invalidate ();
_scrollView.Invalidate();
_scrollView.RequestLayout();
}
}
}
static int? GetRotation(string filePath)
{
try
{
var ei = new ExifInterface(filePath);
var orientation = (Orientation)ei.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Normal);
switch (orientation)
{
case Orientation.Rotate90:
return 90;
case Orientation.Rotate180:
return 180;
case Orientation.Rotate270:
return 270;
default:
return null;
}
}
catch (Exception ex)
{
#if DEBUG
throw ex;
#else
return null;
#endif
}
}
int NeededRotation(Java.IO.File ff)
{
try
{
// extract the header info
ExifInterface exif = new ExifInterface( ff.AbsolutePath );
// determine how we should rotate the image
int orientation = exif.GetAttributeInt( ExifInterface.TagOrientation, 0 );
switch( orientation )
{
case 3: return 180;
case 6: return 90;
case 8: return 270;
}
return 0;
}
catch (Exception )
{
}
return 0;
}
private Bitmap LoadAndResizeBitmap()
{
if (Path.StartsWith("http"))
{
//var webImage = GetImageBitmapFromUrl(Path);
//return Bitmap.CreateScaledBitmap(webImage, _screenWidth, _screenHeight, false);
return GetImageBitmapFromUrl(Path);
}
// First we get the the dimensions of the file on disk
BitmapFactory.Options options = new BitmapFactory.Options { InJustDecodeBounds = true };
BitmapFactory.DecodeFile(Path, options);
// Next we calculate the ratio that we need to resize the image by
// in order to fit the requested dimensions.
int outHeight = options.OutHeight;
int outWidth = options.OutWidth;
int inSampleSize = 1;
if (outHeight > _screenHeight || outWidth > _screenWidth)
{
inSampleSize = outWidth > outHeight
? outHeight / _screenHeight
: outWidth / _screenWidth;
}
// Now we will load the image and have BitmapFactory resize it for us.
options.InSampleSize = inSampleSize;
options.InJustDecodeBounds = false;
Bitmap resizedBitmap = BitmapFactory.DecodeFile(Path, options);
// Images are being saved in landscape, so rotate them back to portrait if they were taken in portrait
Matrix mtx = new Matrix();
ExifInterface exif = new ExifInterface(Path);
string orientation = exif.GetAttribute(ExifInterface.TagOrientation);
switch (orientation)
{
case "6": // portrait
mtx.PreRotate(90);
resizedBitmap = Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
case "1": // landscape
break;
default:
mtx.PreRotate(90);
resizedBitmap = Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
}
return resizedBitmap;
}
private async Task GeoTagPhotoAsync()
{
// see if the photo already contains geo coords
var exif = new ExifInterface(_file.Path);
if (!string.IsNullOrWhiteSpace(exif.GetAttribute(ExifInterface.TagGpsLatitude)))
return;
RequestCurrentLocation();
var location = await _locationTCS.Task;
try
{
int num1Lat = (int)Math.Floor(location.Latitude);
int num2Lat = (int)Math.Floor((location.Latitude - num1Lat) * 60);
double num3Lat = (location.Latitude - ((double)num1Lat + ((double)num2Lat / 60))) * 3600000;
int num1Lon = (int)Math.Floor(location.Longitude);
int num2Lon = (int)Math.Floor((location.Longitude - num1Lon) * 60);
double num3Lon = (location.Longitude - ((double)num1Lon + ((double)num2Lon / 60))) * 3600000;
exif.SetAttribute(ExifInterface.TagGpsLatitude, num1Lat + "/1," + num2Lat + "/1," + num3Lat + "/1000");
exif.SetAttribute(ExifInterface.TagGpsLongitude, num1Lon + "/1," + num2Lon + "/1," + num3Lon + "/1000");
if (location.Latitude > 0)
{
exif.SetAttribute(ExifInterface.TagGpsLatitudeRef, "N");
}
else
{
exif.SetAttribute(ExifInterface.TagGpsLatitudeRef, "S");
}
if (location.Longitude > 0)
{
exif.SetAttribute(ExifInterface.TagGpsLongitudeRef, "E");
}
else
{
exif.SetAttribute(ExifInterface.TagGpsLongitudeRef, "W");
}
exif.SaveAttributes();
}
catch (Java.IO.IOException)
{
// location will not be available on this image, but continue
}
}
public static Bitmap LoadAndResizeBitmap(this string fileName, int width, int height)
{
// First we get the the dimensions of the file on disk
BitmapFactory.Options options = new BitmapFactory.Options { InJustDecodeBounds = true };
BitmapFactory.DecodeFile(fileName, options);
// Next we calculate the ratio that we need to resize the image by
// in order to fit the requested dimensions.
int outHeight = options.OutHeight;
int outWidth = options.OutWidth;
int inSampleSize = 1;
if (outHeight > height || outWidth > width)
{
inSampleSize = outWidth > outHeight
? outHeight / height
: outWidth / width;
}
// Now we will load the image and have BitmapFactory resize it for us.
options.InSampleSize = inSampleSize;
options.InJustDecodeBounds = false;
Bitmap resizedBitmap = BitmapFactory.DecodeFile(fileName, options);
// Images are being saved in landscape, so rotate them back to portrait if they were taken in portrait
Matrix mtx = new Matrix();
ExifInterface exif = new ExifInterface(fileName);
var orientation = (Orientation)exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Undefined);
switch (orientation)
{
case Orientation.Undefined: // Nexus 7 landscape...
break;
case Orientation.Normal: // landscape
break;
case Orientation.FlipHorizontal:
break;
case Orientation.Rotate180:
mtx.PreRotate(180);
resizedBitmap = Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
case Orientation.FlipVertical:
break;
case Orientation.Transpose:
break;
case Orientation.Rotate90: // portrait
mtx.PreRotate(90);
resizedBitmap = Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
case Orientation.Transverse:
break;
case Orientation.Rotate270: // might need to flip horizontally too...
mtx.PreRotate(270);
resizedBitmap = Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
default:
mtx.PreRotate(90);
resizedBitmap = Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
}
return resizedBitmap;
}
public void OnPictureTaken(byte[] data, Android.Hardware.Camera camera)
{
FileOutputStream output = null;
string path = System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments), "Images");
if (!System.IO.Directory.Exists(path))
System.IO.Directory.CreateDirectory(path);
string filename = PictureName + number.ToString() + ".jpg";
if (data != null)
{
fullFilename = System.IO.Path.Combine(path, filename);
number++;
try
{
output = new FileOutputStream(fullFilename);
output.Write(data);
output.Close();
}
catch (FileNotFoundException)
{
RunOnUiThread(delegate
{
GeneralUtils.Alert(context, Application.Context.Resources.GetString(Resource.String.commonError),
Application.Context.Resources.GetString(Resource.String.errorFileTransfer));
});
return;
}
catch (IOException)
{
RunOnUiThread(delegate
{
GeneralUtils.Alert(context, Application.Context.Resources.GetString(Resource.String.commonError),
Application.Context.Resources.GetString(Resource.String.errorNoImagesTaken));
});
isRunning = true;
camera.StartPreview();
return;
}
catch (Exception e)
{
#if DEBUG
System.Diagnostics.Debug.WriteLine("Exception thrown - {0}", e.Message);
#endif
return;
}
var f = new File(fullFilename);
try
{
var exifInterface = new ExifInterface(f.CanonicalPath);
exifInterface.GetAttribute(ExifInterface.TagModel);
var latLong = new float[2];
exifInterface.GetLatLong(latLong);
exifInterface.SetAttribute(ExifInterface.TagMake, "Phone picture");
exifInterface.SetAttribute(ExifInterface.TagDatetime, DateTime.Now.ToString());
}
catch (IOException)
{
RunOnUiThread(delegate
{
GeneralUtils.Alert(context, Application.Context.Resources.GetString(Resource.String.commonError),
Application.Context.Resources.GetString(Resource.String.errorStoreEXIF));
});
isRunning = true;
camera.StartPreview();
return;
}
}
RunOnUiThread(() => Toast.MakeText(context, Application.Context.Resources.GetString(Resource.String.commonPictureTaken), ToastLength.Short).Show());
isRunning = true;
camera.StartPreview();
return;
}
private Android.Graphics.Bitmap LoadAndResizeBitmap(string fileName, Size newSize) {
var exif = new ExifInterface(fileName);
var width = exif.GetAttributeInt(ExifInterface.TagImageWidth, 100);
var height = exif.GetAttributeInt(ExifInterface.TagImageLength, 80);
var orientation = exif.GetAttribute(ExifInterface.TagOrientation);
// We calculate the ratio that we need to resize the image by
// in order to fit the requested dimensions.
var inSampleSize = 1.0;
if (newSize.Height < height || newSize.Width < width) {
inSampleSize = newSize.Width > newSize.Height
? newSize.Height / height
: newSize.Width / width;
}
var options = new Android.Graphics.BitmapFactory.Options {
InJustDecodeBounds = false,
InSampleSize = (int)inSampleSize
};
// Now we will load the image and have BitmapFactory resize it for us.
var resizedBitmap = Android.Graphics.BitmapFactory.DecodeFile(fileName, options);
var rotate = false;
switch (orientation) {
case "1": // landscape
case "3": // landscape
if (width < height)
rotate = true;
break;
case "8":
case "4":
case "6": // portrait
if (width > height)
rotate = true;
break;
case "0": //undefined
default:
break;
}
if (rotate) {
var mtx = new Android.Graphics.Matrix();
mtx.PreRotate(90);
resizedBitmap = Android.Graphics.Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
}
return resizedBitmap;
}
public async Task<bool> DownloadFiles ( List<string> downloadUrlList, CancellationToken cancelToken )
{
int imgMaxWidth = (int)(App.screenWidth * App.screenDensity);
int imgMaxHeight = (int)(App.screenHeight * .50 * App.screenDensity);
int streamLength = 0;
try
{
foreach (var item in downloadUrlList)
{
cancelToken.ThrowIfCancellationRequested();
string fileName = System.IO.Path.GetFileName(item);
WebClient webClient = new WebClient();
if( !File.Exists( App.DownloadsPath + fileName ))
{
await webClient.DownloadFileTaskAsync ( item, App.DownloadsPath + fileName );
webClient.Dispose();
try {
BitmapFactory.Options imgOptions = new BitmapFactory.Options();
imgOptions.InJustDecodeBounds = true;
MemoryStream memStream = null;
await BitmapFactory.DecodeFileAsync(App.DownloadsPath + fileName,imgOptions);
if(imgOptions.OutHeight <= 5000 && imgOptions.OutWidth <= 5000 )
{
using (FileStream fs = File.OpenRead(App.DownloadsPath + fileName))
{
streamLength = (int)fs.Length;
if(streamLength < 5242880) // 5MB = 5242880 byts, 2.5 MB = 2621440 byts
{
memStream = new MemoryStream();
fs.CopyTo(memStream);
}
fs.Close();
fs.Dispose();
}
if (memStream != null && memStream.ToArray().Length > 0)
{
Bitmap originalImage = null;
streamLength = (int)memStream.ToArray().Length;
if(streamLength < 4242880 ) // 5MB = 5242880 byts, 2.5 MB = 2621440 byts
{
try {
originalImage = BitmapFactory.DecodeByteArray(memStream.ToArray(), 0, memStream.ToArray().Length);
}
catch (Exception ex)
{
var test = ex.Message;
FileStream fstream = new FileStream(App.DownloadsPath + fileName, FileMode.Create);
fstream.Close();
fstream.Dispose();
fstream = null;
continue;
}
if(originalImage.Height > originalImage.Width)
{
if (originalImage.Height > 300 || originalImage.Width > 300) {
originalImage = Bitmap.CreateScaledBitmap(originalImage, imgMaxWidth, imgMaxHeight, true);
}
}
else
{
if (originalImage.Width > imgMaxHeight || originalImage.Height > imgMaxWidth) {
originalImage = Bitmap.CreateScaledBitmap(originalImage, imgMaxWidth, imgMaxWidth, true);
}
}
int compressionRate = 100;
#region compression ratio
if (streamLength < 20000) {
compressionRate = 100;
}
else if (streamLength < 40000) {
compressionRate = App.screenDensity > 2 ? 100: 95;
}
else if (streamLength < 50000) {
compressionRate = App.screenDensity > 2 ? 100: 91;
}
else if (streamLength < 100000) {
compressionRate = App.screenDensity > 2 ? 100: 90;
}
else if (streamLength < 200000) {
compressionRate = App.screenDensity > 2 ? 99: 89;
}
else if (streamLength <300000) {
compressionRate = App.screenDensity > 2 ? 98: 88;
}
else if (streamLength < 400000) {
compressionRate = App.screenDensity > 2 ? 97: 87;
}
else if (streamLength < 500000) {
compressionRate = App.screenDensity > 2 ? 96: 86;
}
else if (streamLength < 600000) {
compressionRate = App.screenDensity > 2 ? 95: 86;
}
else if (streamLength < 700000) {
compressionRate = App.screenDensity > 2 ? 94: 86;
}
else if (streamLength < 900000) {
compressionRate = App.screenDensity > 2 ? 92: 86;
}
else if (streamLength < 1000000) {
compressionRate = App.screenDensity > 2 ? 90: 86;
}
else if (streamLength < 2000000) {
compressionRate = App.screenDensity > 2 ? 85: 86;
}
else {
compressionRate = App.screenDensity > 2 ? 80: 85;
}
#endregion
ExifInterface exif = new ExifInterface(App.DownloadsPath+fileName);
var orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Android.Media.Orientation.Normal);
int orientationP = exif.GetAttributeInt (ExifInterface.TagOrientation, 0);
switch (orientation)
{
case (int)Android.Media.Orientation.Rotate180:
originalImage = changeOrientation (App.DownloadsPath + fileName, originalImage, orientationP);
break;
case (int) Android.Media.Orientation.Rotate270:
originalImage = changeOrientation (App.DownloadsPath + fileName, originalImage, orientationP);
break;
case (int)Android.Media.Orientation.Rotate90:
originalImage = changeOrientation (App.DownloadsPath + fileName, originalImage, orientationP);
break;
default:
break;
}
exif.Dispose();
exif = null;
FileStream stream = new FileStream(App.DownloadsPath + fileName, FileMode.Create);
originalImage.Compress(Bitmap.CompressFormat.Jpeg, compressionRate, stream);
stream.Close();
stream.Dispose();
stream = null;
memStream.Dispose();
memStream = null;
//resizedImage.Dispose();
//resizedImage = null;
originalImage.Recycle();
originalImage.Dispose();
originalImage = null;
}
else
{
FileStream fstream = new FileStream(App.DownloadsPath + fileName, FileMode.Create);
fstream.Close();
fstream.Dispose();
fstream = null;
}
}
}
else
{
FileStream fstream = new FileStream(App.DownloadsPath + fileName, FileMode.Create);
fstream.Close();
fstream.Dispose();
fstream = null;
}
} catch (Exception ex) {
var test = ex.Message;
FileStream fstream = new FileStream(App.DownloadsPath + fileName, FileMode.Create);
fstream.Close();
fstream.Dispose();
fstream = null;
}
}// if file exists
} //foreach
return true;
}
catch (Exception ex)
{
Debug.WriteLine ( ex.Message );
return false;
}
}