public void SurfaceChanged(ISurfaceHolder holder, [GeneratedEnum] Format format, int width, int height)
{
if (surfaceHolder.Surface == null)
{
return;
}
try
{
cameraInstance.StopPreview();
cameraInstance.SetPreviewDisplay(surfaceHolder);
Android.Hardware.Camera.Parameters parameters = cameraInstance.GetParameters();
Android.Hardware.Camera.Size optimalSize = CameraHelpers.GetOptimalPreviewSize(context, cameraInstance, width, height);
parameters.SetPreviewSize(optimalSize.Width, optimalSize.Height);
parameters.SetPictureSize(optimalSize.Width, optimalSize.Height);
parameters.FocusMode = Android.Hardware.Camera.Parameters.FocusModeContinuousPicture;
cameraInstance.SetParameters(parameters);
cameraInstance.SetDisplayOrientation(CameraHelpers.GetCameraOrientation(context));
cameraInstance.StartPreview();
}
catch (Exception e)
{
Log.Debug("Camera activity", "Error starting camera preview: " + e.Message);
}
}
public static Android.Hardware.Camera.Size GetOptimalPictureSize(this Android.Hardware.Camera.Parameters p, int w)
{
var sizes = p.SupportedPictureSizes;
int offset = Integer.MaxValue;
Android.Hardware.Camera.Size rs = null;
if (sizes != null)
{
foreach (var size in sizes)
{
if (size.Width >= size.Height)
{
int curSize = size.Width;
if (size.Height >= w && size.Height >= w && (curSize - w) < offset)
{
offset = curSize - w;
rs = size;
}
}
}
}
return(rs);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
var width = ResolveSize(SuggestedMinimumWidth, widthMeasureSpec);
var height = ResolveSize(SuggestedMinimumHeight, heightMeasureSpec);
if (_mSupportedPreviewSizes != null)
{
_mPreviewSize = GetOptimalPreviewSize(_mSupportedPreviewSizes, width, height);
}
float ratio;
if (_mPreviewSize.Height >= _mPreviewSize.Width)
{
ratio = _mPreviewSize.Height / (float)_mPreviewSize.Width;
}
else
{
ratio = _mPreviewSize.Width / (float)_mPreviewSize.Height;
}
// One of these methods should be used, second method squishes preview slightly
SetMeasuredDimension(width, (int)(width * ratio));
InitPictureSize();
}
private void UpdateCameraAspect()
{
try
{
Android.Hardware.Camera.Parameters camParams = camera.GetParameters();
Android.Hardware.Camera.CameraInfo info = new Android.Hardware.Camera.CameraInfo();
Android.Hardware.Camera.GetCameraInfo((int)Android.Hardware.CameraFacing.Back, info);
Android.Hardware.Camera.Size size = GetOptimalPreviewSize(camParams.SupportedPreviewSizes, width, height);
camParams.SetPreviewSize(size.Width, size.Height);
int rotation = (info.Orientation + 360) % 360;
camParams.SetRotation(rotation);
if (camParams.SupportedFocusModes.Contains(Android.Hardware.Camera.Parameters.FocusModeContinuousPicture))
{
camParams.FocusMode = Android.Hardware.Camera.Parameters.FocusModeContinuousPicture;
}
camera.SetParameters(camParams);
}
catch (System.Exception e)
{
System.Console.WriteLine(e.Message);
}
}
public void setResolution(Size resolution)
{
DisconnectCamera();
MMaxHeight = (int)resolution.Height;
MMaxWidth = (int)resolution.Width;
ConnectCamera(Width, Height);
}
private Android.Hardware.Camera.Size getOptimalSize(int width, int height, List <Android.Hardware.Camera.Size> sizes)
{
Android.Hardware.Camera.Size pictureSize = sizes[0];
List <Android.Hardware.Camera.Size> candidates = new List <Android.Hardware.Camera.Size>();
foreach (Android.Hardware.Camera.Size size in sizes)
{
if (size.Width >= width && size.Height >= height && size.Width * height == size.Height * width)
{
// 比例相同
candidates.Add(size);
}
else if (size.Height >= width && size.Width >= height && size.Width * width == size.Height * height)
{
// 反比例
candidates.Add(size);
}
}
//if (candidates != null)
//{
// return Collections.Min(candidates, sizeComparator);
//}
foreach (Android.Hardware.Camera.Size size in sizes)
{
if (size.Width >= width && size.Height >= height)
{
return(size);
}
}
return(pictureSize);
}
private Android.Hardware.Camera.Size GetOptimalPreviewSize(IList <Android.Hardware.Camera.Size> sizes, int w, int h)
{
const double ASPECT_TOLERANCE = 0.05;
double targetRatio = (double)w / h;
int maxSize = 1228800 * 2;
if (sizes == null)
{
return(null);
}
Android.Hardware.Camera.Size optimalSize = null;
double minDiff = System.Double.MaxValue;
int targetHeight = h;
// Try to find an size match aspect ratio and size
foreach (Android.Hardware.Camera.Size size in sizes)
{
double ratio = (double)size.Height / size.Width;
if (size.Height * size.Width > maxSize)
{
continue;
}
if (System.Math.Abs(ratio - targetRatio) > ASPECT_TOLERANCE)
{
continue;
}
if (System.Math.Abs(size.Height - targetHeight) < minDiff)
{
optimalSize = size;
minDiff = System.Math.Abs(size.Height - targetHeight);
}
}
// Cannot find the one match the aspect ratio, ignore the requirement
if (optimalSize == null)
{
minDiff = System.Double.MaxValue;
foreach (Android.Hardware.Camera.Size size in sizes)
{
if (size.Height * size.Width > maxSize)
{
continue;
}
if (System.Math.Abs(size.Height - targetHeight) < minDiff)
{
optimalSize = size;
minDiff = System.Math.Abs(size.Height - targetHeight);
}
}
}
return(optimalSize);
}
internal Android.Hardware.Camera.Size GetOptimalPreviewSize(IList <Android.Hardware.Camera.Size> sizes)
{
const double ASPECT_TOLERANCE = 0.05;
string TAG = "GetOptimalPreviewSize";
if (sizes == null)
{
return(null);
}
Android.Hardware.Camera.Size optimalSize = null;
double minDiff = System.Double.MaxValue;
Point display_size = new Point();
//AppCompatActivity activity = (AppCompatActivity)this.BaseContext;
{
Display display = this.WindowManager.DefaultDisplay;
display.GetSize(display_size);
Log.Debug(TAG, "display_size: " + display_size.X + " x " + display_size.Y);
}
double targetRatio = CalculateTargetRatioForPreview(display_size);
int targetHeight = System.Math.Min(display_size.Y, display_size.X);
if (targetHeight <= 0)
{
targetHeight = display_size.Y;
}
// Try to find the size which matches the aspect ratio, and is closest match to display height
foreach (Android.Hardware.Camera.Size size in sizes)
{
Log.Debug(TAG, " supported preview size: " + size.Width + ", " + size.Height);
double ratio = (double)size.Width / size.Height;
if (System.Math.Abs(ratio - targetRatio) > ASPECT_TOLERANCE)
{
continue;
}
if (System.Math.Abs(size.Height - targetHeight) < minDiff)
{
optimalSize = size;
minDiff = System.Math.Abs(size.Height - targetHeight);
}
}
if (optimalSize == null)
{
// can't find match for aspect ratio, so find closest one
Log.Debug(TAG, "no preview size matches the aspect ratio");
optimalSize = GetClosestSize(sizes, targetRatio);
}
optimalSize = sizes[1];
Log.Debug(TAG, "chose optimalSize: " + optimalSize.Width + " x " + optimalSize.Height);
Log.Debug(TAG, "optimalSize ratio: " + ((double)optimalSize.Width / optimalSize.Height));
return(optimalSize);
}
internal Android.Hardware.Camera.Size GetOptimalPreviewSizeNotinUse(IList <Android.Hardware.Camera.Size> sizes, int w, int h)
{
double ASPECT_TOLERANCE = 0.1;
double targetRatio = (double)h / w;
if (Resources.Configuration.Orientation == Android.Content.Res.Orientation.Portrait)
{
targetRatio = (double)h / (double)w;
}
else if (Resources.Configuration.Orientation == Android.Content.Res.Orientation.Landscape)
{
targetRatio = (double)w / (double)h;
}
if (sizes == null)
{
return(null);
}
Android.Hardware.Camera.Size optimalSize = null;
double minDiff = System.Double.MaxValue;
int targetHeight = h;
foreach (Android.Hardware.Camera.Size size in sizes)
{
double ratio = (double)size.Height / size.Width;
if (Java.Lang.Math.Abs(ratio - targetRatio) > ASPECT_TOLERANCE)
{
continue;
}
if (Java.Lang.Math.Abs(size.Height - targetHeight) < minDiff)
{
optimalSize = size;
minDiff = Java.Lang.Math.Abs(size.Height - targetHeight);
}
}
if (optimalSize == null)
{
minDiff = Java.Lang.Double.MaxValue;
foreach (Android.Hardware.Camera.Size size in sizes)
{
//Console.WriteLine("FIXED HEIGHT:"+size.Height+" WIDTH:"+size.Width);
if (Java.Lang.Math.Abs(size.Height - targetHeight) < minDiff)
{
optimalSize = size;
minDiff = Java.Lang.Math.Abs(size.Height - targetHeight);
}
}
}
return(optimalSize);
}
private Android.Hardware.Camera.Parameters GetCameraParams(Android.Hardware.Camera camera)
{
var paramsCamera = camera.GetParameters();
IList <Android.Hardware.Camera.Size> supportedSizes =
paramsCamera.SupportedPictureSizes;
Android.Hardware.Camera.Size sizePicture =
supportedSizes[supportedSizes.Count / 2];
paramsCamera.Set("orientation", "landscape");
paramsCamera.Set("rotation", 90);
paramsCamera.SetPictureSize(sizePicture.Width, sizePicture.Height);
return(paramsCamera);
}
public Android.Hardware.Camera.Size GetClosestSize(IList <Android.Hardware.Camera.Size> sizes, double targetRatio)
{
Log.Debug("GetClosestSize", "getClosestSize()");
Android.Hardware.Camera.Size optimalSize = null;
double minDiff = System.Double.MaxValue;
foreach (Android.Hardware.Camera.Size size in sizes)
{
double ratio = (double)size.Width / size.Height;
if (System.Math.Abs(ratio - targetRatio) < minDiff)
{
optimalSize = size;
minDiff = System.Math.Abs(ratio - targetRatio);
}
}
return(optimalSize);
}
private Android.Hardware.Camera.Size GetOptimalPreviewSize(List <Android.Hardware.Camera.Size> sizes, int w, int h)
{
var aspectTolerance = 0.1;
var targetRatio = (double)h / w;
if (sizes == null)
{
return(null);
}
Android.Hardware.Camera.Size optimalSize = null;
var minDiff = double.MaxValue;
var targetHeight = h;
foreach (var size in sizes)
{
var ratio = (double)size.Height / size.Width;
if (Math.Abs(ratio - targetRatio) > aspectTolerance)
{
continue;
}
if (Math.Abs(size.Height - targetHeight) < minDiff)
{
optimalSize = size;
minDiff = Math.Abs(size.Height - targetHeight);
}
}
if (optimalSize == null)
{
minDiff = double.MaxValue;
foreach (var size in sizes)
{
if (Math.Abs(size.Height - targetHeight) < minDiff)
{
optimalSize = size;
minDiff = Math.Abs(size.Height - targetHeight);
}
}
}
return(optimalSize);
}
public static Bitmap convertYuvByteArrayToBitmap(byte[] data, Android.Hardware.Camera camera)
{
try
{
Android.Hardware.Camera.Parameters parameters = camera.GetParameters();
Android.Hardware.Camera.Size size = parameters.PreviewSize;
YuvImage image = new YuvImage(data, parameters.PreviewFormat, size.Width, size.Height, null);
System.IO.MemoryStream out_ = new System.IO.MemoryStream();
image.CompressToJpeg(new Rect(0, 0, size.Width, size.Height), int.Parse(MainValues.quality), out_);
byte[] imageBytes = out_.ToArray();
out_.Flush(); out_.Close(); out_.Dispose();
return(BitmapFactory.DecodeByteArray(imageBytes, 0, imageBytes.Length));
}
catch (Exception)
{
return(null);
}
}
protected Android.Hardware.Camera.Size determineBestSize(IList <Android.Hardware.Camera.Size> sizes, int widthThreshold)
{
Android.Hardware.Camera.Size bestSize = null;
foreach (Android.Hardware.Camera.Size currentSize in sizes)
{
var isDesiredRatio = currentSize.Width / 4 == currentSize.Height / 3;
var isBetterSize = bestSize == null || currentSize.Width > bestSize.Width;
var isInBounds = currentSize.Width <= PICTURE_SIZE_MAX_WIDTH;
if (isDesiredRatio && isInBounds && isBetterSize)
{
bestSize = currentSize;
}
}
return(bestSize ?? sizes.First());
}
public void SurfaceCreated(ISurfaceHolder holder)
{
// TODO Auto-generated method stub
try
{
camera = Android.Hardware.Camera.Open();
Android.Hardware.Camera.Parameters param = camera.GetParameters();
// Check what resolutions are supported by your camera
IList <Android.Hardware.Camera.Size> sizes = param.SupportedPictureSizes;
// setting small image size in order to avoid OOM error
Android.Hardware.Camera.Size cameraSize = null;
foreach (Android.Hardware.Camera.Size size in sizes)
{
//set whatever size you need
//if(size.height<500) {
cameraSize = size;
break;
//}
}
if (cameraSize != null)
{
param.SetPictureSize(cameraSize.Width, cameraSize.Height);
camera.SetParameters(param);
float ratio = relativeLayout.Height * 1f / cameraSize.Height;
float w = cameraSize.Width * ratio;
float h = cameraSize.Height * ratio;
RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams((int)w, (int)h);
cameraSurfaceView.LayoutParameters = (lp);
}
}
catch (RuntimeException e)
{
Toast.MakeText(
ApplicationContext,
"Device camera is not working properly, please try after sometime.",
ToastLength.Long).Show();
}
}
private Bitmap convertYuvByteArrayToBitmap(byte[] data, Android.Hardware.Camera camera)
{
try
{
Android.Hardware.Camera.Parameters parameters = camera.GetParameters();
Android.Hardware.Camera.Size size = parameters.PreviewSize;
using (YuvImage image = new YuvImage(data, parameters.PreviewFormat, size.Width, size.Height, null))
{
using (MemoryStream memoryStream = new MemoryStream())
{
image.CompressToJpeg(new Rect(0, 0, size.Width, size.Height), int.Parse(MainValues.quality), memoryStream);
return(BitmapFactory.DecodeByteArray(memoryStream.ToArray(), 0, memoryStream.ToArray().Length));
}
}
}
catch (Exception)
{
return(null);
}
}
public override bool OnOptionsItemSelected(IMenuItem item)
{
Log.Info(TAG, "called onOptionsItemSelected; selected item: " + item);
if (item.GroupId == 1)
{
mOpenCvCameraView.setEffect((string)item.TitleFormatted.ToString());
Toast.MakeText(this, mOpenCvCameraView.getEffect(), ToastLength.Short).Show();
}
else if (item.GroupId == 2)
{
int id = item.ItemId;
Size resolution = mResolutionList[id];
mOpenCvCameraView.setResolution(resolution);
resolution = mOpenCvCameraView.getResolution();
string caption = resolution.Width.ToString() + "x" + resolution.Height.ToString();
Toast.MakeText(this, caption, ToastLength.Short).Show();
}
return(true);
}
private void opPreviewSize(int width, int height)
{
if (camera != null && width > 0)
{
try
{
Android.Hardware.Camera.Parameters parameters = camera.GetParameters();
Android.Hardware.Camera.Size optSize = getOptimalSize(width, height, new List <Android.Hardware.Camera.Size>(camera.GetParameters().SupportedPreviewSizes));
Log.Info("wtf", "opPreviewSize-> " + optSize.Width + " " + optSize.Height);
parameters.SetPreviewSize(optSize.Width, optSize.Height);
// parameters.setPreviewFpsRange(10, 15);
camera.SetParameters(parameters);
camera.StartPreview();
}
catch (RuntimeException e)
{
e.PrintStackTrace();
}
}
}
public static Android.Hardware.Camera.Size GetPictureSize(this Android.Hardware.Camera.Parameters p, int w)
{
var sizes = p.SupportedPictureSizes;
var sizes2 = p.SupportedPreviewSizes;
var offset = Integer.MaxValue;
Android.Hardware.Camera.Size rs = null;
if (sizes != null)
{
foreach (var size in sizes)
{
foreach (var size2 in sizes2)
{
if (size.Width == size2.Width && size.Height == size2.Height)
{
int curSize = 0;
if (size.Width > size.Height)
{
curSize = size.Width;
}
else
{
curSize = size.Height;
}
if (size.Width >= w && size.Height >= w && (curSize - w) < offset)
{
offset = curSize - w;
rs = size;
}
}
}
}
}
return(rs);
}
public override bool OnCreateOptionsMenu(IMenu menu)
{
IList <string> effects = mOpenCvCameraView.getEffectList();
if (effects == null)
{
Log.Error(TAG, "Color effects are not supported by device!");
return(true);
}
mColorEffectsMenu = menu.AddSubMenu("Color Effect");
mEffectMenuItems = new IMenuItem[effects.Count];
int idx = 0;
foreach (var item in effects)
{
string element = item;
mEffectMenuItems[idx] = mColorEffectsMenu.Add(1, idx, Menu.None, element);
idx++;
}
mResolutionMenu = menu.AddSubMenu("Resolution");
mResolutionList = mOpenCvCameraView.getResolutionList();
mResolutionMenuItems = new IMenuItem[mResolutionList.Count];
idx = 0;
foreach (var item in mResolutionList)
{
Size element = item;
mResolutionMenuItems[idx] = mResolutionMenu.Add(2, idx, Menu.None,
element.Width.ToString() + "x" + element.Height.ToString());
idx++;
}
return(true);
}
public static Android.Hardware.Camera.Size GetOptimalPreviewSize(this Android.Hardware.Camera.Parameters p,
Android.Hardware.Camera.Size pictureSize)
{
var sizes = p.SupportedPreviewSizes;
float pictureRatio = pictureSize.Width / pictureSize.Height;
int offset = Integer.MaxValue;
Android.Hardware.Camera.Size rs = null;
if (sizes != null)
{
foreach (var size in sizes)
{
float tempRatio = size.Width / size.Height;
if (tempRatio == pictureRatio)
{
if (rs == null)
{
rs = size;
}
else
{
int tempOffset = Math.Abs(size.Width - pictureSize.Height);
if (tempOffset < offset)
{
offset = tempOffset;
rs = size;
}
}
}
}
}
return(rs);
}
public void SurfaceChanged(ISurfaceHolder holder, [GeneratedEnum] Format format, int width, int height)
{
// TODO Auto-generated method stub
if (previewing)
{
camera.StopPreview();
previewing = false;
}
try
{
float w = 0;
float h = 0;
if (this.Resources.Configuration.Orientation != Android.Content.Res.Orientation.Landscape)
{
camera.SetDisplayOrientation(90);
Android.Hardware.Camera.Size cameraSize = camera.GetParameters().PictureSize;
int wr = relativeLayout.Width;
int hr = relativeLayout.Height;
float ratio = relativeLayout.Width * 1f / cameraSize.Height;
w = cameraSize.Width * ratio;
h = cameraSize.Height * ratio;
RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams((int)h, (int)w);
cameraSurfaceView.LayoutParameters = (lp);
frameImageView.LayoutParameters = lp;
}
else
{
camera.SetDisplayOrientation(0);
Android.Hardware.Camera.Size cameraSize = camera.GetParameters().PictureSize;
float ratio = relativeLayout.Height * 1f / cameraSize.Height;
w = cameraSize.Width * ratio;
h = cameraSize.Height * ratio;
RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams((int)w, (int)h);
cameraSurfaceView.LayoutParameters = (lp);
frameImageView.LayoutParameters = lp;
}
camera.SetPreviewDisplay(cameraSurfaceHolder);
camera.StartPreview();
previewing = true;
//float imgHeight = frameImageView.Height;
//float imgeWidth = frameImageView.Width;
float imgeWidth = frameImageView.Drawable.IntrinsicWidth;
float imgHeight = frameImageView.Drawable.IntrinsicHeight;
DisplayMetrics displayMetrics = new DisplayMetrics();
WindowManager.DefaultDisplay.GetMetrics(displayMetrics);
int widthS = displayMetrics.WidthPixels;
float hR = h / imgHeight;
float wR = w / widthS;
//framMatrix.SetScale(2*wR,2*hR);
frameImageView.SetScaleType(ImageView.ScaleType.FitXy);
}
catch (System.Exception e)
{
// TODO Auto-generated catch block
System.Console.WriteLine("SurfaceChanged:" + e.ToString());
}
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
int width = ResolveSize(SuggestedMinimumWidth, widthMeasureSpec);
int height = ResolveSize(SuggestedMinimumHeight, heightMeasureSpec);
if (mSupportedPreviewSizes != null)
{
mPreviewSize = _Context.GetOptimalPreviewSize(mSupportedPreviewSizes);
}
float ratio;
if (mPreviewSize.Height >= mPreviewSize.Width)
{
ratio = (float)mPreviewSize.Height / (float)mPreviewSize.Width;
}
else
{
ratio = (float)mPreviewSize.Width / (float)mPreviewSize.Height;
}
// One of these methods should be used, second method squishes preview slightly
SetMeasuredDimension(width, (int)(width * ratio));
return;
// We purposely disregard child measurements because act as a
// wrapper to a SurfaceView that centers the camera preview instead
// of stretching it.
//int width = ResolveSize(SuggestedMinimumWidth, widthMeasureSpec);
//int height = ResolveSize(SuggestedMinimumHeight, heightMeasureSpec);
//SetMeasuredDimension(width, height);
//if (mSupportedPreviewSizes != null)
//{
// mPreviewSize = GetOptimalPreviewSize(mSupportedPreviewSizes, width, height);
//}
//int width = ResolveSize(SuggestedMinimumWidth, widthMeasureSpec);
//int height = ResolveSize(SuggestedMinimumHeight, heightMeasureSpec);
//SetMeasuredDimension(width, height);
//if (mSupportedPreviewSizes != null)
//{
// mPreviewSize = GetOptimalPreviewSize(mSupportedPreviewSizes, width, height);
//}
mPreviewSize = _Context.GetOptimalPreviewSize(mSupportedPreviewSizes);
if (mPreviewSize != null)
{
SetMeasuredDimension(width, height);
//float ratio;
//if (mPreviewSize.Height >= mPreviewSize.Width)
// ratio = (float)mPreviewSize.Height / (float)mPreviewSize.Width;
//else
// ratio = (float)mPreviewSize.Width / (float)mPreviewSize.Height;
//// One of these methods should be used, second method squishes preview slightly
////SetMeasuredDimension(width, (int)(width * ratio));
//// setMeasuredDimension((int) (width * ratio), height);
//float camHeight = (int)(width * ratio);
//float newCamHeight;
//float newHeightRatio;
//if (camHeight < height)
//{
// newHeightRatio = (float)height / (float)mPreviewSize.Height;
// newCamHeight = (newHeightRatio * camHeight);
// System.Console.WriteLine(camHeight + " " + height + " " + mPreviewSize.Height + " " + newHeightRatio + " " + newCamHeight);
// SetMeasuredDimension((int)(width * newHeightRatio), (int)newCamHeight);
// //System.Console.WriteLine(mPreviewSize.Width + " | " + mPreviewSize.Height + " | ratio - " + ratio + " | H_ratio - " + newHeightRatio + " | A_width - " + (width * newHeightRatio) + " | A_height - " + newCamHeight);
// //mPreviewSize.Width = (int)(width * newHeightRatio);
// //mPreviewSize.Height = (int)newCamHeight;
//}
//else
//{
// newCamHeight = camHeight;
// SetMeasuredDimension(width, (int)newCamHeight);
// //System.Console.WriteLine(mPreviewSize.Width + " | " + mPreviewSize.Height + " | ratio - " + ratio + " | A_width - " + (width) + " | A_height - " + newCamHeight);
// //mPreviewSize.Width = width;
// //mPreviewSize.Height = (int)newCamHeight;
//}
}
}
private void InitLeadCam()
{
if (leadCamera.Camera == null)
{
_cameraObjectNotReady = true;
return;
}
if (!cleanup || AppResumed)
{
leadCamera.Camera.Start();
//reset the clean up flag
cleanup = true;
AppResumed = false;
leadCamera.RotationChanged += LeadCamera_RotationChanged;
leadCamera.PictureReceived += LeadCamera_PictureReceived;
if (_enableAutoCapture)
{
leadCamera.FrameReceived += LeadCamera_FrameReceived;
}
return;
}
if (_enableAutoCapture)
{
Animation labelFadeAnimation = new Animation();
Animation fadeOutAnimation = new Animation
(
callback: d => autoCaptureLabel.Opacity = d,
start: 1,
end: 0.25,
easing: Easing.SinInOut
);
Animation fadeInAnimation = new Animation
(
callback: e =>
{
autoCaptureLabel.Opacity = e;
},
start: 0.25,
end: 1,
easing: Easing.SinInOut
);
labelFadeAnimation.Add(0, 0.5, fadeOutAnimation);
labelFadeAnimation.Add(0.5, 1, fadeInAnimation);
autoCaptureLabel.Animate("FadeInOut", labelFadeAnimation, length: 1000, easing: Easing.SinInOut, repeat: () => true);
UpdateCardDetectionStatus();
}
leadCamera.RotationChanged += LeadCamera_RotationChanged;
leadCamera.PictureReceived += LeadCamera_PictureReceived;
leadCamera.CameraOptions.AutoRotateImage = _autoRotateImage;
leadCamera.Camera.FocusMode = FocusMode.Continuous;
#if __IOS__
var ioscam = leadCamera.Camera.NativeCamera as AVFoundation.AVCaptureSession;
if (ioscam != null)
{
var presetValue = ioscam.SessionPreset;
if (HomePage.CurrentAppData.CameraQuality == Utils.CameraQuality.Medium)
{
presetValue = new Foundation.NSString("AVCaptureSessionPreset1920x1080");
}
else
{
presetValue = new Foundation.NSString("AVCaptureSessionPreset3840x2160");
}
try
{
foreach (AVFoundation.AVCaptureOutput output in ioscam.Outputs)
{
if (output is AVFoundation.AVCaptureStillImageOutput stillImageOutput)
{
stillImageOutput.HighResolutionStillImageOutputEnabled = (HomePage.CurrentAppData.CameraQuality == Utils.CameraQuality.High) ? true : false;
}
}
ioscam.SessionPreset = presetValue;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
#else
//set capture quality setting
#pragma warning disable CS0618 // Type or member is obsolete
var droidcam = leadCamera.Camera.NativeCamera as Android.Hardware.Camera;
var parameters = droidcam.GetParameters();
var pictureSizes = parameters.SupportedPictureSizes;
if (pictureSizes != null)
{
Android.Hardware.Camera.Size closestMatch = null;
if (HomePage.CurrentAppData.CameraQuality == Utils.CameraQuality.Medium)
{
// Get the first camera size with width bigger than 2000
var closestMatches = pictureSizes.OrderByDescending(x => x.Width).Where(x => x.Width > 2000);
if (closestMatches != null && closestMatches.Count() > 0)
{
closestMatch = closestMatches.Last();
}
}
else
{
var closestMatches = pictureSizes.OrderByDescending(x => x.Width).Where(x => x.Width > 3800);
if (closestMatches != null && closestMatches.Count() > 0)
{
closestMatch = closestMatches.Last();
}
}
if (closestMatch == null)
{
closestMatch = pictureSizes.OrderByDescending(x => x.Height).First();
}
parameters.SetPictureSize(closestMatch.Width, closestMatch.Height);
droidcam.SetParameters(parameters);
}
#pragma warning restore CS0618 // Type or member is obsolete
#endif
autoCaptureGrid.IsVisible = _enableAutoCapture;
if (_enableAutoCapture)
{
leadCamera.FrameReceived += LeadCamera_FrameReceived;
}
}
private void configureCameraAndStartPreview(Android.Hardware.Camera camera)
{
// Setting camera parameters when preview is running can cause crashes on some android devices
stopPreview();
// Configure camera orientation. This is needed for both correct preview orientation
// and recognition
orientation = getCameraOrientation();
camera.SetDisplayOrientation(orientation);
// Configure camera parameters
Android.Hardware.Camera.Parameters parameters = camera.GetParameters();
// Select preview size. The preferred size for Text Capture scenario is 1080x720. In some scenarios you might
// consider using higher resolution (small text, complex background) or lower resolution (better performance, less noise)
cameraPreviewSize = null;
foreach (Android.Hardware.Camera.Size size in parameters.SupportedPreviewSizes)
{
if (size.Height <= 720 || size.Width <= 720)
{
if (cameraPreviewSize == null)
{
cameraPreviewSize = size;
}
else
{
int resultArea = cameraPreviewSize.Width * cameraPreviewSize.Height;
int newArea = size.Width * size.Height;
if (newArea > resultArea)
{
cameraPreviewSize = size;
}
}
}
}
parameters.SetPreviewSize(cameraPreviewSize.Width, cameraPreviewSize.Height);
// Zoom
parameters.Zoom = cameraZoom;
// Buffer format. The only currently supported format is NV21
parameters.PreviewFormat = Android.Graphics.ImageFormatType.Nv21;
// Default focus mode
parameters.FocusMode = Android.Hardware.Camera.Parameters.FocusModeAuto;
// Done
camera.SetParameters(parameters);
// The camera will fill the buffers with image data and notify us through the callback.
// The buffers will be sent to camera on requests from recognition service (see implementation
// of ITextCaptureService.Callback.onRequestLatestFrame above)
camera.SetPreviewCallbackWithBuffer(cameraPreviewCallback);
// Clear the previous recognition results if any
clearRecognitionResults();
// Width and height of the preview according to the current screen rotation
int width = 0;
int height = 0;
switch (orientation)
{
case 0:
case 180:
width = cameraPreviewSize.Width;
height = cameraPreviewSize.Height;
break;
case 90:
case 270:
width = cameraPreviewSize.Height;
height = cameraPreviewSize.Width;
break;
}
// Configure the view scale and area of interest (camera sees it as rotated 90 degrees, so
// there's some confusion with what is width and what is height)
surfaceViewWithOverlay.setScaleX(surfaceViewWithOverlay.Width, width);
surfaceViewWithOverlay.setScaleY(surfaceViewWithOverlay.Height, height);
// Area of interest
int marginWidth = (areaOfInterestMargin_PercentOfWidth * width) / 100;
int marginHeight = (areaOfInterestMargin_PercentOfHeight * height) / 100;
surfaceViewWithOverlay.setAreaOfInterest(
new Rect(marginWidth, marginHeight, width - marginWidth,
height - marginHeight));
// Start preview
camera.StartPreview();
setCameraFocusMode(Android.Hardware.Camera.Parameters.FocusModeAuto);
autoFocus(finishCameraInitialisationAutoFocusCallback);
inPreview = true;
}
public void OnPictureTaken(byte[] data, Android.Hardware.Camera camera)
{
// TODO Auto-generated method stub
BitmapFactory.Options options = new BitmapFactory.Options();
//o.inJustDecodeBounds = true;
Bitmap cameraBitmapNull = BitmapFactory.DecodeByteArray(data, 0, data.Length, options);
int wid = options.OutWidth;
int hgt = options.OutHeight;
Matrix nm = new Matrix();
Android.Hardware.Camera.Size cameraSize = camera.GetParameters().PictureSize;
float ratio = relativeLayout.Height * 1f / cameraSize.Height;
if (Resources.Configuration.Orientation != Android.Content.Res.Orientation.Landscape)
{
nm.PostRotate(90);
nm.PostTranslate(hgt, 0);
wid = options.OutHeight;
hgt = options.OutWidth;
ratio = relativeLayout.Width * 1f / cameraSize.Height;
}
else
{
wid = options.OutWidth;
hgt = options.OutHeight;
ratio = relativeLayout.Height * 1f / cameraSize.Height;
}
float[] f = new float[9];
float[] f1 = new float[9];
matrix.GetValues(f);
framMatrix.GetValues(f1);
f[0] = f[0] / ratio;
f[4] = f[4] / ratio;
f[5] = f[5] / ratio;
f[2] = f[2] / ratio;
f1[0] = f1[0] / ratio;
f1[4] = f1[4] / ratio;
f1[5] = f1[5] / ratio;
f1[2] = f1[2] / ratio;
matrix.SetValues(f);
framMatrix.SetValues(f1);
Bitmap newBitmap = Bitmap.CreateBitmap(wid, hgt, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(newBitmap);
Bitmap cameraBitmap = BitmapFactory.DecodeByteArray(data, 0, data.Length, options);
canvas.DrawBitmap(cameraBitmap, nm, null);
cameraBitmap.Recycle();
canvas.DrawBitmap(bitmap, matrix, null);
bitmap.Recycle();
Bitmap bbb = Bitmap.CreateScaledBitmap(bitmap2, cameraBitmap.Height, cameraBitmap.Width, false);
canvas.DrawBitmap(bbb, new Matrix(), null);
bbb.Recycle();
Java.IO.File storagePath = new Java.IO.File(Android.OS.Environment.ExternalStorageDirectory + "/PhotoAR/");
storagePath.Mkdirs();
Java.IO.File myImage = new Java.IO.File(storagePath, Long.ToString(JavaSystem.CurrentTimeMillis()) + ".jpg");
try
{
//string path = System.IO.Path.Combine(Environment.GetExternalStoragePublicDirectory(Environment.DirectoryPictures).AbsolutePath, "newProdict.png");
string path = myImage.AbsolutePath;
var fs = new FileStream(path, FileMode.OpenOrCreate);
if (fs != null)
{
newBitmap.Compress(Bitmap.CompressFormat.Jpeg, 80, fs);
fs.Close();
}
//Stream outs = new FileOutputStream(myImage);
//newBitmap.Compress(Bitmap.CompressFormat.Jpeg, 80, outs);
//out.flush();
//out.close();
}
catch (System.Exception e)
{
Log.Debug("In Saving File", e + "");
}
}
internal Bitmap ProcessImage(byte[] data, Android.Hardware.Camera camera)
{
Bitmap newBitmap = null;
try
{
// TODO Auto-generated method stub
int orientation = Exif.GetExifOrientations(data);
BitmapFactory.Options options = new BitmapFactory.Options();
//o.inJustDecodeBounds = true;
Bitmap cameraBitmapNull = BitmapFactory.DecodeByteArray(data, 0, data.Length, options);
Bitmap bitmapPicture = null;
int extraangle = 180;
switch (orientation)
{
case 90:
bitmapPicture = RotateImage(cameraBitmapNull, 180);
break;
case 180:
bitmapPicture = RotateImage(cameraBitmapNull, 270);
break;
case 270:
bitmapPicture = RotateImage(cameraBitmapNull, 360);
break;
case 0:
bitmapPicture = RotateImage(cameraBitmapNull, 90);
break;
// if orientation is zero we don't need to rotate this
default:
bitmapPicture = RotateImage(cameraBitmapNull, 90);
break;
}
int wid = options.OutWidth;
int hgt = options.OutHeight;
Matrix nm = new Matrix();
Android.Hardware.Camera.Size cameraSize = camera.GetParameters().PictureSize;
float ratio = mPreview.Height * 1f / cameraSize.Height;
if (Resources.Configuration.Orientation != Android.Content.Res.Orientation.Landscape)
{
//nm.PostRotate(90);
//nm.PostTranslate(hgt, 0);
wid = options.OutHeight;
hgt = options.OutWidth;
ratio = mPreview.Width * 1f / cameraSize.Height;
}
else
{
wid = options.OutWidth;
hgt = options.OutHeight;
ratio = mPreview.Height * 1f / cameraSize.Height;
}
float[] f = new float[9];
matrix.GetValues(f);
f[0] = f[0] / ratio;
f[4] = f[4] / ratio;
f[5] = f[5] / ratio;
f[2] = f[2] / ratio;
matrix.SetValues(f);
newBitmap = Bitmap.CreateBitmap(wid, hgt, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(newBitmap);
//Bitmap cameraBitmap = BitmapFactory.DecodeByteArray(data, 0, data.Length, options);
canvas.DrawBitmap(bitmapPicture, nm, null);
canvas.DrawBitmap(bitmaptrophy, matrix, null);
camera.StartPreview();
}
catch (System.Exception ex)
{
System.Console.WriteLine("ON PICTURE Ex:" + ex.ToString());
}
return(newBitmap);
}
private void startCamera()
{
if (ContextCompat.CheckSelfPermission(context, Manifest.Permission.Camera)
!= Android.Content.PM.Permission.Granted)
{
if (permissionCallback != null)
{
permissionCallback.onRequestPermission();
}
return;
}
if (camera == null)
{
Android.Hardware.Camera.CameraInfo cameraInfo = new Android.Hardware.Camera.CameraInfo();
for (int i = 0; i < Android.Hardware.Camera.NumberOfCameras; i++)
{
Android.Hardware.Camera.GetCameraInfo(i, cameraInfo);
if ((int)cameraInfo.Facing == cameraFacing)
{
cameraId = i;
}
}
camera = Android.Hardware.Camera.Open(cameraId);
}
// if (parameters == null) {
// parameters = camera.getParameters();
// parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
// }
int detectRotation = 0;
if (cameraFacing == 1)
{
int rotation = ORIENTATIONS.Get(displayOrientation);
rotation = getCameraDisplayOrientation(rotation, cameraId, camera);
camera.SetDisplayOrientation(rotation);
detectRotation = rotation;
if (displayOrientation == 0)
{
if (detectRotation == 90 || detectRotation == 270)
{
detectRotation = (detectRotation + 180) % 360;
}
}
}
else if (cameraFacing == 0)
{
int rotation = ORIENTATIONS.Get(displayOrientation);
rotation = getCameraDisplayOrientation(rotation, cameraId, camera);
camera.SetDisplayOrientation(rotation);
detectRotation = rotation;
}
else if (cameraFacing == 2)
{
camera.SetDisplayOrientation(0);
detectRotation = 0;
}
opPreviewSize(preferredWidth, preferredHeight);
Android.Hardware.Camera.Size size = camera.GetParameters().PreviewSize;
if (detectRotation % 180 == 90)
{
previewView.setPreviewSize(size.Height, size.Width);
}
else
{
previewView.setPreviewSize(size.Width, size.Height);
}
int temp = detectRotation;
try
{
// if (cameraFacing == ICameraControl.CAMERA_USB) {
// camera.SetPreviewTexture(textureView.getSurfaceTexture());
// } else {
// surfaceTexture = new SurfaceTexture(11);
// camera.setPreviewTexture(surfaceTexture);
// uiHandler.post(new Runnable() {
// @Override
// public void run() {
//
// if (textureView != null) {
// surfaceTexture.detachFromGLContext();
// textureView.setSurfaceTexture(surfaceTexture);
// }
// }
// });
// }
// camera.addCallbackBuffer(new byte[size.width * size.height * 3 / 2]);
// camera.setPreviewCallbackWithBuffer(new Camera.PreviewCallback() {
//
// @Override
// public void onPreviewFrame(byte[] data, Camera camera) {
// Log.i("wtf", "onPreviewFrame-->");
// onFrameListener.onPreviewFrame(data, temp, size.width, size.height);
// camera.addCallbackBuffer(data);
// ad }
// });
// camera.setPreviewCallback(new Camera.PreviewCallback() {
// public void onPreviewFrame(byte[] data, Camera camera)
// {
// LogUtil.i("wtf", "onPreviewFrame-->");
// onFrameListener.onPreviewFrame(data, temp, size.width, size.height);
// }
//});
}
catch (IOException e)
{
e.PrintStackTrace();
LogUtil.i("wtf", e.ToString());
}
catch (RuntimeException e)
{
e.PrintStackTrace();
LogUtil.i("wtf", e.ToString());
}
}
