internal CameraResolution GetResolution(List <CameraResolution> availableResolutions)
{
CameraResolution r = null;
var dg = CameraResolutionSelector;
if (dg != null)
{
r = dg(availableResolutions);
}
return(r);
}
bool SetupCaptureSession()
{
var started = DateTime.UtcNow;
var availableResolutions = new List <CameraResolution> ();
var consideredResolutions = new Dictionary <NSString, CameraResolution> {
{ AVCaptureSession.Preset352x288, new CameraResolution {
Width = 352, Height = 288
} },
{ AVCaptureSession.PresetMedium, new CameraResolution {
Width = 480, Height = 360
} }, //480x360
{ AVCaptureSession.Preset640x480, new CameraResolution {
Width = 640, Height = 480
} },
{ AVCaptureSession.Preset1280x720, new CameraResolution {
Width = 1280, Height = 720
} },
{ AVCaptureSession.Preset1920x1080, new CameraResolution {
Width = 1920, Height = 1080
} }
};
// configure the capture session for low resolution, change this if your code
// can cope with more data or volume
session = new AVCaptureSession()
{
SessionPreset = AVCaptureSession.Preset640x480
};
// create a device input and attach it to the session
// var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType (AVMediaType.Video);
AVCaptureDevice captureDevice = null;
var devices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
foreach (var device in devices)
{
captureDevice = device;
if (options.UseFrontCameraIfAvailable.HasValue &&
options.UseFrontCameraIfAvailable.Value &&
device.Position == AVCaptureDevicePosition.Front)
{
break; //Front camera successfully set
}
else if (device.Position == AVCaptureDevicePosition.Back && (!options.UseFrontCameraIfAvailable.HasValue || !options.UseFrontCameraIfAvailable.Value))
{
break; //Back camera succesfully set
}
}
if (captureDevice == null)
{
Console.WriteLine("No captureDevice - this won't work on the simulator, try a physical device");
if (overlayView != null)
{
this.AddSubview(overlayView);
this.BringSubviewToFront(overlayView);
}
return(false);
}
CameraResolution resolution = null;
// Find resolution
// Go through the resolutions we can even consider
foreach (var cr in consideredResolutions)
{
// Now check to make sure our selected device supports the resolution
// so we can add it to the list to pick from
if (captureDevice.SupportsAVCaptureSessionPreset(cr.Key))
{
availableResolutions.Add(cr.Value);
}
}
resolution = options.GetResolution(availableResolutions);
// See if the user selected a resolution
if (resolution != null)
{
// Now get the preset string from the resolution chosen
var preset = (from c in consideredResolutions
where c.Value.Width == resolution.Width &&
c.Value.Height == resolution.Height
select c.Key).FirstOrDefault();
// If we found a matching preset, let's set it on the session
if (!string.IsNullOrEmpty(preset))
{
session.SessionPreset = preset;
}
}
var input = AVCaptureDeviceInput.FromDevice(captureDevice);
if (input == null)
{
Console.WriteLine("No input - this won't work on the simulator, try a physical device");
if (overlayView != null)
{
this.AddSubview(overlayView);
this.BringSubviewToFront(overlayView);
}
return(false);
}
else
{
session.AddInput(input);
}
var startedAVPreviewLayerAlloc = DateTime.UtcNow;
previewLayer = new AVCaptureVideoPreviewLayer(session);
var totalAVPreviewLayerAlloc = DateTime.UtcNow - startedAVPreviewLayerAlloc;
Console.WriteLine("PERF: Alloc AVCaptureVideoPreviewLayer took {0} ms.", totalAVPreviewLayerAlloc.TotalMilliseconds);
// //Framerate set here (15 fps)
// if (UIDevice.CurrentDevice.CheckSystemVersion (7, 0))
// {
// var perf1 = PerformanceCounter.Start ();
// NSError lockForConfigErr = null;
// captureDevice.LockForConfiguration (out lockForConfigErr);
// if (lockForConfigErr == null)
// {
// captureDevice.ActiveVideoMinFrameDuration = new CMTime (1, 10);
// captureDevice.UnlockForConfiguration ();
// }
// PerformanceCounter.Stop (perf1, "PERF: ActiveVideoMinFrameDuration Took {0} ms");
// }
// else
// previewLayer.Connection.VideoMinFrameDuration = new CMTime(1, 10);
var perf2 = PerformanceCounter.Start();
#if __UNIFIED__
previewLayer.VideoGravity = AVLayerVideoGravity.ResizeAspectFill;
#else
previewLayer.LayerVideoGravity = AVLayerVideoGravity.ResizeAspectFill;
#endif
previewLayer.Frame = new CGRect(0, 0, this.Frame.Width, this.Frame.Height);
previewLayer.Position = new CGPoint(this.Layer.Bounds.Width / 2, (this.Layer.Bounds.Height / 2));
layerView = new UIView(new CGRect(0, 0, this.Frame.Width, this.Frame.Height));
layerView.AutoresizingMask = UIViewAutoresizing.FlexibleWidth | UIViewAutoresizing.FlexibleHeight;
layerView.Layer.AddSublayer(previewLayer);
this.AddSubview(layerView);
ResizePreview(UIApplication.SharedApplication.StatusBarOrientation);
if (overlayView != null)
{
this.AddSubview(overlayView);
this.BringSubviewToFront(overlayView);
//overlayView.LayoutSubviews ();
}
PerformanceCounter.Stop(perf2, "PERF: Setting up layers took {0} ms");
var perf3 = PerformanceCounter.Start();
session.StartRunning();
PerformanceCounter.Stop(perf3, "PERF: session.StartRunning() took {0} ms");
var perf4 = PerformanceCounter.Start();
var videoSettings = NSDictionary.FromObjectAndKey(new NSNumber((int)CVPixelFormatType.CV32BGRA),
CVPixelBuffer.PixelFormatTypeKey);
// create a VideoDataOutput and add it to the sesion
output = new AVCaptureVideoDataOutput {
WeakVideoSettings = videoSettings
};
// configure the output
queue = new DispatchQueue("ZxingScannerView"); // (Guid.NewGuid().ToString());
var barcodeReader = new BarcodeReaderiOS(null, (img) =>
{
var src = new RGBLuminanceSourceiOS(img); //, bmp.Width, bmp.Height);
//Don't try and rotate properly if we're autorotating anyway
if (ScanningOptions.AutoRotate.HasValue && ScanningOptions.AutoRotate.Value)
{
return(src);
}
var tmpInterfaceOrientation = UIInterfaceOrientation.Portrait;
InvokeOnMainThread(() => tmpInterfaceOrientation = UIApplication.SharedApplication.StatusBarOrientation);
switch (tmpInterfaceOrientation)
{
case UIInterfaceOrientation.Portrait:
return(src.rotateCounterClockwise().rotateCounterClockwise().rotateCounterClockwise());
case UIInterfaceOrientation.PortraitUpsideDown:
return(src.rotateCounterClockwise().rotateCounterClockwise().rotateCounterClockwise());
case UIInterfaceOrientation.LandscapeLeft:
return(src);
case UIInterfaceOrientation.LandscapeRight:
return(src);
}
return(src);
}, null, null); //(p, w, h, f) => new RGBLuminanceSource(p, w, h, RGBLuminanceSource.BitmapFormat.Unknown));
if (ScanningOptions.TryHarder.HasValue)
{
Console.WriteLine("TRY_HARDER: " + ScanningOptions.TryHarder.Value);
barcodeReader.Options.TryHarder = ScanningOptions.TryHarder.Value;
}
if (ScanningOptions.PureBarcode.HasValue)
{
barcodeReader.Options.PureBarcode = ScanningOptions.PureBarcode.Value;
}
if (ScanningOptions.AutoRotate.HasValue)
{
Console.WriteLine("AUTO_ROTATE: " + ScanningOptions.AutoRotate.Value);
barcodeReader.AutoRotate = ScanningOptions.AutoRotate.Value;
}
if (!string.IsNullOrEmpty(ScanningOptions.CharacterSet))
{
barcodeReader.Options.CharacterSet = ScanningOptions.CharacterSet;
}
if (ScanningOptions.TryInverted.HasValue)
{
barcodeReader.TryInverted = ScanningOptions.TryInverted.Value;
}
if (ScanningOptions.PossibleFormats != null && ScanningOptions.PossibleFormats.Count > 0)
{
barcodeReader.Options.PossibleFormats = new List <BarcodeFormat>();
foreach (var pf in ScanningOptions.PossibleFormats)
{
barcodeReader.Options.PossibleFormats.Add(pf);
}
}
outputRecorder = new OutputRecorder(ScanningOptions, img =>
{
if (!IsAnalyzing)
{
return(false);
}
try
{
//var sw = new System.Diagnostics.Stopwatch();
//sw.Start();
var rs = barcodeReader.Decode(img);
//sw.Stop();
//Console.WriteLine("Decode Time: {0} ms", sw.ElapsedMilliseconds);
if (rs != null)
{
resultCallback(rs);
return(true);
}
}
catch (Exception ex)
{
Console.WriteLine("DECODE FAILED: " + ex);
}
return(false);
});
output.AlwaysDiscardsLateVideoFrames = true;
output.SetSampleBufferDelegate(outputRecorder, queue);
PerformanceCounter.Stop(perf4, "PERF: SetupCamera Finished. Took {0} ms.");
session.AddOutput(output);
//session.StartRunning ();
var perf5 = PerformanceCounter.Start();
NSError err = null;
if (captureDevice.LockForConfiguration(out err))
{
if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
{
captureDevice.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
}
else if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.AutoFocus))
{
captureDevice.FocusMode = AVCaptureFocusMode.AutoFocus;
}
if (captureDevice.IsExposureModeSupported(AVCaptureExposureMode.ContinuousAutoExposure))
{
captureDevice.ExposureMode = AVCaptureExposureMode.ContinuousAutoExposure;
}
else if (captureDevice.IsExposureModeSupported(AVCaptureExposureMode.AutoExpose))
{
captureDevice.ExposureMode = AVCaptureExposureMode.AutoExpose;
}
if (captureDevice.IsWhiteBalanceModeSupported(AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance))
{
captureDevice.WhiteBalanceMode = AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance;
}
else if (captureDevice.IsWhiteBalanceModeSupported(AVCaptureWhiteBalanceMode.AutoWhiteBalance))
{
captureDevice.WhiteBalanceMode = AVCaptureWhiteBalanceMode.AutoWhiteBalance;
}
if (UIDevice.CurrentDevice.CheckSystemVersion(7, 0) && captureDevice.AutoFocusRangeRestrictionSupported)
{
captureDevice.AutoFocusRangeRestriction = AVCaptureAutoFocusRangeRestriction.Near;
}
if (captureDevice.FocusPointOfInterestSupported)
{
captureDevice.FocusPointOfInterest = new PointF(0.5f, 0.5f);
}
if (captureDevice.ExposurePointOfInterestSupported)
{
captureDevice.ExposurePointOfInterest = new PointF(0.5f, 0.5f);
}
captureDevice.UnlockForConfiguration();
}
else
{
Console.WriteLine("Failed to Lock for Config: " + err.Description);
}
PerformanceCounter.Stop(perf5, "PERF: Setup Focus in {0} ms.");
return(true);
}
public async Task StartScanningAsync(Action <Result> scanResultCallback, MobileBarcodeScanningOptions options = null)
{
this.callback = scanResultCallback;
this.scanningOptions = options ?? MobileBarcodeScanningOptions.Default;
lastPreviewAnalysis = DateTime.UtcNow.AddMilliseconds(this.scanningOptions.InitialDelayBeforeAnalyzingFrames);
isAnalyzing = true;
Console.WriteLine("StartScanning");
CheckCameraPermissions();
var perf = PerformanceCounter.Start();
GetExclusiveAccess();
try {
var version = Build.VERSION.SdkInt;
if (version >= BuildVersionCodes.Gingerbread)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Checking Number of cameras...");
var numCameras = Camera.NumberOfCameras;
var camInfo = new Camera.CameraInfo();
var found = false;
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Found " + numCameras + " cameras...");
var whichCamera = CameraFacing.Back;
if (this.scanningOptions.UseFrontCameraIfAvailable.HasValue && this.scanningOptions.UseFrontCameraIfAvailable.Value)
{
whichCamera = CameraFacing.Front;
}
for (int i = 0; i < numCameras; i++)
{
Camera.GetCameraInfo(i, camInfo);
if (camInfo.Facing == whichCamera)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Found " + whichCamera + " Camera, opening...");
camera = Camera.Open(i);
cameraId = i;
found = true;
break;
}
}
if (!found)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Finding " + whichCamera + " camera failed, opening camera 0...");
camera = Camera.Open(0);
cameraId = 0;
}
}
else
{
camera = Camera.Open();
}
if (camera == null)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Camera is null :(");
}
camera.SetPreviewCallback(this);
} catch (Exception ex) {
ShutdownCamera();
Console.WriteLine("Setup Error: " + ex);
}
PerformanceCounter.Stop(perf, "Camera took {0}ms");
if (!surfaceChanged)
{
await waitSurface.WaitAsync();
}
if (camera == null)
{
return;
}
perf = PerformanceCounter.Start();
var parameters = camera.GetParameters();
parameters.PreviewFormat = ImageFormatType.Nv21;
var availableResolutions = new List <CameraResolution> ();
foreach (var sps in parameters.SupportedPreviewSizes)
{
availableResolutions.Add(new CameraResolution {
Width = sps.Width,
Height = sps.Height
});
}
// Try and get a desired resolution from the options selector
var resolution = scanningOptions.GetResolution(availableResolutions);
// If the user did not specify a resolution, let's try and find a suitable one
if (resolution == null)
{
// Loop through all supported sizes
foreach (var sps in parameters.SupportedPreviewSizes)
{
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000)
{
resolution = new CameraResolution {
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
// Google Glass requires this fix to display the camera output correctly
if (Build.Model.Contains("Glass"))
{
resolution = new CameraResolution {
Width = 640,
Height = 360
};
// Glass requires 30fps
parameters.SetPreviewFpsRange(30000, 30000);
}
// Hopefully a resolution was selected at some point
if (resolution != null)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Selected Resolution: " + resolution.Width + "x" + resolution.Height);
parameters.SetPreviewSize(resolution.Width, resolution.Height);
}
camera.SetParameters(parameters);
SetCameraDisplayOrientation(this.activity);
camera.SetPreviewDisplay(this.Holder);
camera.StartPreview();
PerformanceCounter.Stop(perf, "SurfaceChanged took {0}ms");
AutoFocus();
}
public async Task StartScanningAsync(Action<ZXing.Result> scanCallback, MobileBarcodeScanningOptions options = null)
{
if (stopping)
return;
isAnalyzing = true;
ScanCallback = scanCallback;
ScanningOptions = options ?? MobileBarcodeScanningOptions.Default;
topText.Text = TopText ?? string.Empty;
bottomText.Text = BottomText ?? string.Empty;
if (UseCustomOverlay)
{
gridCustomOverlay.Children.Clear();
if (CustomOverlay != null)
gridCustomOverlay.Children.Add(CustomOverlay);
gridCustomOverlay.Visibility = Visibility.Visible;
gridDefaultOverlay.Visibility = Visibility.Collapsed;
}
else
{
gridCustomOverlay.Visibility = Visibility.Collapsed;
gridDefaultOverlay.Visibility = Visibility.Visible;
}
// Find which device to use
var preferredCamera = await this.GetFilteredCameraOrDefaultAsync(ScanningOptions);
mediaCapture = new MediaCapture();
// Initialize the capture with the settings above
await mediaCapture.InitializeAsync(new MediaCaptureInitializationSettings()
{
StreamingCaptureMode = StreamingCaptureMode.Video,
VideoDeviceId = preferredCamera.Id
});
// Set the capture element's source to show it in the UI
captureElement.Source = mediaCapture;
// Start the preview
await mediaCapture.StartPreviewAsync();
// Get all the available resolutions for preview
var availableProperties = mediaCapture.VideoDeviceController.GetAvailableMediaStreamProperties(MediaStreamType.VideoPreview);
var availableResolutions = new List<CameraResolution>();
foreach (var ap in availableProperties)
{
var vp = (VideoEncodingProperties)ap;
System.Diagnostics.Debug.WriteLine("Camera Preview Resolution: {0}x{1}", vp.Width, vp.Height);
availableResolutions.Add(new CameraResolution { Width = (int)vp.Width, Height = (int)vp.Height });
}
CameraResolution previewResolution = null;
if (ScanningOptions.CameraResolutionSelector != null)
previewResolution = ScanningOptions.CameraResolutionSelector(availableResolutions);
// If the user did not specify a resolution, let's try and find a suitable one
if (previewResolution == null)
{
// Loop through all supported sizes
foreach (var sps in availableResolutions)
{
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000)
{
previewResolution = new CameraResolution
{
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
if (previewResolution == null)
previewResolution = availableResolutions.LastOrDefault();
System.Diagnostics.Debug.WriteLine("Using Preview Resolution: {0}x{1}", previewResolution.Width, previewResolution.Height);
// Find the matching property based on the selection, again
var chosenProp = availableProperties.FirstOrDefault(ap => ((VideoEncodingProperties)ap).Width == previewResolution.Width && ((VideoEncodingProperties)ap).Height == previewResolution.Height);
// Set the selected resolution
await mediaCapture.VideoDeviceController.SetMediaStreamPropertiesAsync(MediaStreamType.VideoPreview, chosenProp);
await SetPreviewRotationAsync();
captureElement.Stretch = Stretch.UniformToFill;
// Get our preview properties
var previewProperties = mediaCapture.VideoDeviceController.GetMediaStreamProperties(MediaStreamType.VideoPreview) as VideoEncodingProperties;
// Setup a frame to use as the input settings
var destFrame = new VideoFrame(Windows.Graphics.Imaging.BitmapPixelFormat.Bgra8, (int)previewProperties.Width, (int)previewProperties.Height);
var zxing = ScanningOptions.BuildBarcodeReader();
timerPreview = new Timer(async (state) => {
if (stopping)
return;
if (mediaCapture == null || mediaCapture.CameraStreamState != Windows.Media.Devices.CameraStreamState.Streaming)
return;
if (processing)
return;
if (!isAnalyzing)
return;
processing = true;
SoftwareBitmapLuminanceSource luminanceSource = null;
try
{
// Get preview
var frame = await mediaCapture.GetPreviewFrameAsync(destFrame);
// Create our luminance source
luminanceSource = new SoftwareBitmapLuminanceSource(frame.SoftwareBitmap);
} catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("GetPreviewFrame Failed: {0}", ex);
}
ZXing.Result result = null;
try
{
// Try decoding the image
if (luminanceSource != null)
result = zxing.Decode(luminanceSource);
}
catch (Exception ex)
{
}
// Check if a result was found
if (result != null && !string.IsNullOrEmpty (result.Text))
{
if (!ContinuousScanning)
await StopScanningAsync();
LastScanResult = result;
ScanCallback(result);
}
processing = false;
}, null, TimeSpan.FromMilliseconds(200), TimeSpan.FromMilliseconds(200));
}
bool SetupCaptureSession()
{
var availableResolutions = new List <CameraResolution> ();
var consideredResolutions = new Dictionary <NSString, CameraResolution> {
{ AVCaptureSession.Preset352x288, new CameraResolution {
Width = 352, Height = 288
} },
{ AVCaptureSession.PresetMedium, new CameraResolution {
Width = 480, Height = 360
} }, //480x360
{ AVCaptureSession.Preset640x480, new CameraResolution {
Width = 640, Height = 480
} },
{ AVCaptureSession.Preset1280x720, new CameraResolution {
Width = 1280, Height = 720
} },
{ AVCaptureSession.Preset1920x1080, new CameraResolution {
Width = 1920, Height = 1080
} }
};
// configure the capture session for low resolution, change this if your code
// can cope with more data or volume
session = new AVCaptureSession()
{
SessionPreset = AVCaptureSession.Preset640x480
};
// create a device input and attach it to the session
// var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType (AVMediaType.Video);
AVCaptureDevice captureDevice = null;
var devices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
foreach (var device in devices)
{
captureDevice = device;
if (options.UseFrontCameraIfAvailable.HasValue &&
options.UseFrontCameraIfAvailable.Value &&
device.Position == AVCaptureDevicePosition.Front)
{
break; //Front camera successfully set
}
else if (device.Position == AVCaptureDevicePosition.Back && (!options.UseFrontCameraIfAvailable.HasValue || !options.UseFrontCameraIfAvailable.Value))
{
break; //Back camera succesfully set
}
}
if (captureDevice == null)
{
Console.WriteLine("No captureDevice - this won't work on the simulator, try a physical device");
if (overlayView != null)
{
this.AddSubview(overlayView);
this.BringSubviewToFront(overlayView);
}
return(false);
}
CameraResolution resolution = null;
// Find resolution
// Go through the resolutions we can even consider
foreach (var cr in consideredResolutions)
{
// Now check to make sure our selected device supports the resolution
// so we can add it to the list to pick from
if (captureDevice.SupportsAVCaptureSessionPreset(cr.Key))
{
availableResolutions.Add(cr.Value);
}
}
resolution = options.GetResolution(availableResolutions);
// See if the user selected a resolution
if (resolution != null)
{
// Now get the preset string from the resolution chosen
var preset = (from c in consideredResolutions
where c.Value.Width == resolution.Width &&
c.Value.Height == resolution.Height
select c.Key).FirstOrDefault();
// If we found a matching preset, let's set it on the session
if (!string.IsNullOrEmpty(preset))
{
session.SessionPreset = preset;
}
}
var input = AVCaptureDeviceInput.FromDevice(captureDevice);
if (input == null)
{
Console.WriteLine("No input - this won't work on the simulator, try a physical device");
if (overlayView != null)
{
this.AddSubview(overlayView);
this.BringSubviewToFront(overlayView);
}
return(false);
}
else
{
session.AddInput(input);
}
foundResult = false;
//Detect barcodes with built in avcapture stuff
AVCaptureMetadataOutput metadataOutput = new AVCaptureMetadataOutput();
captureDelegate = new CaptureDelegate(metaDataObjects =>
{
if (!analyzing)
{
return;
}
//Console.WriteLine("Found MetaData Objects");
var msSinceLastPreview = (DateTime.UtcNow - lastAnalysis).TotalMilliseconds;
if (msSinceLastPreview < options.DelayBetweenAnalyzingFrames ||
(wasScanned && msSinceLastPreview < options.DelayBetweenContinuousScans) ||
working)
//|| CancelTokenSource.IsCancellationRequested)
{
return;
}
working = true;
wasScanned = false;
lastAnalysis = DateTime.UtcNow;
var mdo = metaDataObjects.FirstOrDefault();
if (mdo == null)
{
return;
}
var readableObj = mdo as AVMetadataMachineReadableCodeObject;
if (readableObj == null)
{
return;
}
wasScanned = true;
var zxingFormat = ZXingBarcodeFormatFromAVCaptureBarcodeFormat(readableObj.Type.ToString());
var rs = new ZXing.Result(readableObj.StringValue, null, null, zxingFormat);
resultCallback(rs);
working = false;
});
metadataOutput.SetDelegate(captureDelegate, DispatchQueue.MainQueue);
session.AddOutput(metadataOutput);
//Setup barcode formats
if (ScanningOptions.PossibleFormats != null && ScanningOptions.PossibleFormats.Count > 0)
{
#if __UNIFIED__
var formats = AVMetadataObjectType.None;
foreach (var f in ScanningOptions.PossibleFormats)
{
formats |= AVCaptureBarcodeFormatFromZXingBarcodeFormat(f);
}
formats &= ~AVMetadataObjectType.None;
metadataOutput.MetadataObjectTypes = formats;
#else
var formats = new List <string> ();
foreach (var f in ScanningOptions.PossibleFormats)
{
formats.AddRange(AVCaptureBarcodeFormatFromZXingBarcodeFormat(f));
}
metadataOutput.MetadataObjectTypes = (from f in formats.Distinct() select new NSString(f)).ToArray();
#endif
}
else
{
metadataOutput.MetadataObjectTypes = metadataOutput.AvailableMetadataObjectTypes;
}
previewLayer = new AVCaptureVideoPreviewLayer(session);
//Framerate set here (15 fps)
if (previewLayer.RespondsToSelector(new Selector("connection")))
{
if (UIDevice.CurrentDevice.CheckSystemVersion(7, 0))
{
var perf1 = PerformanceCounter.Start();
NSError lockForConfigErr = null;
captureDevice.LockForConfiguration(out lockForConfigErr);
if (lockForConfigErr == null)
{
captureDevice.ActiveVideoMinFrameDuration = new CMTime(1, 10);
captureDevice.UnlockForConfiguration();
}
PerformanceCounter.Stop(perf1, "PERF: ActiveVideoMinFrameDuration Took {0} ms");
}
else
{
previewLayer.Connection.VideoMinFrameDuration = new CMTime(1, 10);
}
}
#if __UNIFIED__
previewLayer.VideoGravity = AVLayerVideoGravity.ResizeAspectFill;
#else
previewLayer.LayerVideoGravity = AVLayerVideoGravity.ResizeAspectFill;
#endif
previewLayer.Frame = new CGRect(0, 0, this.Frame.Width, this.Frame.Height);
previewLayer.Position = new CGPoint(this.Layer.Bounds.Width / 2, (this.Layer.Bounds.Height / 2));
layerView = new UIView(new CGRect(0, 0, this.Frame.Width, this.Frame.Height));
layerView.AutoresizingMask = UIViewAutoresizing.FlexibleWidth | UIViewAutoresizing.FlexibleHeight;
layerView.Layer.AddSublayer(previewLayer);
this.AddSubview(layerView);
ResizePreview(UIApplication.SharedApplication.StatusBarOrientation);
if (overlayView != null)
{
this.AddSubview(overlayView);
this.BringSubviewToFront(overlayView);
//overlayView.LayoutSubviews ();
}
session.StartRunning();
Console.WriteLine("RUNNING!!!");
//output.AlwaysDiscardsLateVideoFrames = true;
Console.WriteLine("SetupCamera Finished");
//session.AddOutput (output);
//session.StartRunning ();
if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
{
NSError err = null;
if (captureDevice.LockForConfiguration(out err))
{
if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
{
captureDevice.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
}
else if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.AutoFocus))
{
captureDevice.FocusMode = AVCaptureFocusMode.AutoFocus;
}
if (captureDevice.IsExposureModeSupported(AVCaptureExposureMode.ContinuousAutoExposure))
{
captureDevice.ExposureMode = AVCaptureExposureMode.ContinuousAutoExposure;
}
else if (captureDevice.IsExposureModeSupported(AVCaptureExposureMode.AutoExpose))
{
captureDevice.ExposureMode = AVCaptureExposureMode.AutoExpose;
}
if (captureDevice.IsWhiteBalanceModeSupported(AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance))
{
captureDevice.WhiteBalanceMode = AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance;
}
else if (captureDevice.IsWhiteBalanceModeSupported(AVCaptureWhiteBalanceMode.AutoWhiteBalance))
{
captureDevice.WhiteBalanceMode = AVCaptureWhiteBalanceMode.AutoWhiteBalance;
}
if (UIDevice.CurrentDevice.CheckSystemVersion(7, 0) && captureDevice.AutoFocusRangeRestrictionSupported)
{
captureDevice.AutoFocusRangeRestriction = AVCaptureAutoFocusRangeRestriction.Near;
}
if (captureDevice.FocusPointOfInterestSupported)
{
captureDevice.FocusPointOfInterest = new CGPoint(0.5f, 0.5f);
}
if (captureDevice.ExposurePointOfInterestSupported)
{
captureDevice.ExposurePointOfInterest = new CGPoint(0.5f, 0.5f);
}
captureDevice.UnlockForConfiguration();
}
else
{
Console.WriteLine("Failed to Lock for Config: " + err.Description);
}
}
return(true);
}
public void SurfaceChanged(ISurfaceHolder holder, Format format, int w, int h)
{
if (camera == null)
return;
var perf = PerformanceCounter.Start ();
var parameters = camera.GetParameters ();
parameters.PreviewFormat = ImageFormatType.Nv21;
var availableResolutions = new List<CameraResolution> ();
foreach (var sps in parameters.SupportedPreviewSizes) {
availableResolutions.Add (new CameraResolution {
Width = sps.Width,
Height = sps.Height
});
}
// Try and get a desired resolution from the options selector
var resolution = options.GetResolution (availableResolutions);
// If the user did not specify a resolution, let's try and find a suitable one
if (resolution == null) {
// Loop through all supported sizes
foreach (var sps in parameters.SupportedPreviewSizes) {
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000) {
resolution = new CameraResolution {
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
// Google Glass requires this fix to display the camera output correctly
if (Build.Model.Contains ("Glass")) {
resolution = new CameraResolution {
Width = 640,
Height = 360
};
// Glass requires 30fps
parameters.SetPreviewFpsRange (30000, 30000);
}
// Hopefully a resolution was selected at some point
if (resolution != null) {
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Selected Resolution: " + resolution.Width + "x" + resolution.Height);
parameters.SetPreviewSize (resolution.Width, resolution.Height);
}
camera.SetParameters (parameters);
SetCameraDisplayOrientation (this.activity);
camera.SetPreviewDisplay (holder);
camera.StartPreview ();
//cameraResolution = new Size(parameters.PreviewSize.Width, parameters.PreviewSize.Height);
PerformanceCounter.Stop (perf, "SurfaceChanged took {0}ms");
AutoFocus();
}
public async Task StartScanningAsync(Action <ZXing.Result> scanCallback, MobileBarcodeScanningOptions options = null)
{
if (stopping)
{
var error = "Camera is closing";
OnScannerError?.Invoke(new[] { error });
return;
}
displayRequest.RequestActive();
isAnalyzing = true;
ScanCallback = scanCallback;
ScanningOptions = options ?? MobileBarcodeScanningOptions.Default;
topText.Text = TopText ?? string.Empty;
bottomText.Text = BottomText ?? string.Empty;
if (UseCustomOverlay)
{
gridCustomOverlay.Children.Clear();
if (CustomOverlay != null)
{
gridCustomOverlay.Children.Add(CustomOverlay);
}
gridCustomOverlay.Visibility = Visibility.Visible;
gridDefaultOverlay.Visibility = Visibility.Collapsed;
}
else
{
gridCustomOverlay.Visibility = Visibility.Collapsed;
gridDefaultOverlay.Visibility = Visibility.Visible;
}
// Find which device to use
var preferredCamera = await GetFilteredCameraOrDefaultAsync(ScanningOptions);
if (preferredCamera == null)
{
var error = "No camera available";
System.Diagnostics.Debug.WriteLine(error);
isMediaCaptureInitialized = false;
OnScannerError?.Invoke(new[] { error });
return;
}
if (preferredCamera.EnclosureLocation == null || preferredCamera.EnclosureLocation.Panel == Windows.Devices.Enumeration.Panel.Unknown)
{
// No information on the location of the camera, assume it's an external camera, not integrated on the device.
externalCamera = true;
}
else
{
// Camera is fixed on the device.
externalCamera = false;
// Only mirror the preview if the camera is on the front panel.
mirroringPreview = preferredCamera.EnclosureLocation.Panel == Windows.Devices.Enumeration.Panel.Front;
}
mediaCapture = new MediaCapture();
// Initialize the capture with the settings above
try
{
await mediaCapture.InitializeAsync(new MediaCaptureInitializationSettings
{
StreamingCaptureMode = StreamingCaptureMode.Video,
VideoDeviceId = preferredCamera.Id
});
isMediaCaptureInitialized = true;
}
catch (UnauthorizedAccessException)
{
System.Diagnostics.Debug.WriteLine("Denied access to the camera");
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Exception when init MediaCapture: {0}", ex);
}
if (!isMediaCaptureInitialized)
{
var error = "Unexpected error on Camera initialisation";
OnScannerError?.Invoke(new[] { error });
return;
}
// Set the capture element's source to show it in the UI
captureElement.Source = mediaCapture;
captureElement.FlowDirection = mirroringPreview ? FlowDirection.RightToLeft : FlowDirection.LeftToRight;
try
{
// Start the preview
await mediaCapture.StartPreviewAsync();
}
catch (Exception ex)
{
var error = "Unexpected error on Camera initialisation";
OnScannerError?.Invoke(new[] { error });
return;
}
if (mediaCapture.CameraStreamState == CameraStreamState.Streaming)
{
OnCameraInitialized?.Invoke();
}
// Get all the available resolutions for preview
var availableProperties = mediaCapture.VideoDeviceController.GetAvailableMediaStreamProperties(MediaStreamType.VideoPreview);
var availableResolutions = new List <CameraResolution>();
foreach (var ap in availableProperties)
{
var vp = (VideoEncodingProperties)ap;
System.Diagnostics.Debug.WriteLine("Camera Preview Resolution: {0}x{1}", vp.Width, vp.Height);
availableResolutions.Add(new CameraResolution {
Width = (int)vp.Width, Height = (int)vp.Height
});
}
CameraResolution previewResolution = null;
if (ScanningOptions.CameraResolutionSelector != null)
{
previewResolution = ScanningOptions.CameraResolutionSelector(availableResolutions);
}
if (availableResolutions == null || availableResolutions.Count < 1)
{
var error = "Camera is busy. Try to close all applications that use camera.";
OnScannerError?.Invoke(new[] { error });
return;
}
// If the user did not specify a resolution, let's try and find a suitable one
if (previewResolution == null)
{
// Loop through all supported sizes
foreach (var sps in availableResolutions)
{
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000)
{
previewResolution = new CameraResolution
{
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
if (previewResolution == null)
{
previewResolution = availableResolutions.LastOrDefault();
}
if (previewResolution == null)
{
System.Diagnostics.Debug.WriteLine("No preview resolution available. Camera may be in use by another application.");
return;
}
MobileBarcodeScanner.Log("Using Preview Resolution: {0}x{1}", previewResolution.Width, previewResolution.Height);
// Find the matching property based on the selection, again
var chosenProp = availableProperties.FirstOrDefault(ap => ((VideoEncodingProperties)ap).Width == previewResolution.Width && ((VideoEncodingProperties)ap).Height == previewResolution.Height);
// Pass in the requested preview size properties
// so we can set them at the same time as the preview rotation
// to save an additional set property call
await SetPreviewRotationAsync(chosenProp);
// *after* the preview is setup, set this so that the UI layout happens
// otherwise the preview gets stuck in a funny place on screen
captureElement.Stretch = Stretch.UniformToFill;
await SetupAutoFocus();
var zxing = ScanningOptions.BuildBarcodeReader();
timerPreview = new Timer(async(state) =>
{
var delay = ScanningOptions.DelayBetweenAnalyzingFrames;
if (stopping || processing || !isAnalyzing ||
(mediaCapture == null || mediaCapture.CameraStreamState != Windows.Media.Devices.CameraStreamState.Streaming))
{
timerPreview.Change(delay, Timeout.Infinite);
return;
}
processing = true;
SoftwareBitmapLuminanceSource luminanceSource = null;
try
{
// Get preview
var frame = await mediaCapture.GetPreviewFrameAsync(videoFrame);
// Create our luminance source
luminanceSource = new SoftwareBitmapLuminanceSource(frame.SoftwareBitmap);
}
catch (Exception ex)
{
MobileBarcodeScanner.Log("GetPreviewFrame Failed: {0}", ex);
}
ZXing.Result result = null;
try
{
// Try decoding the image
if (luminanceSource != null)
{
result = zxing.Decode(luminanceSource);
}
}
catch (Exception ex)
{
MobileBarcodeScanner.Log("Warning: zxing.Decode Failed: {0}", ex);
}
// Check if a result was found
if (result != null && !string.IsNullOrEmpty(result.Text))
{
if (!ContinuousScanning)
{
delay = Timeout.Infinite;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { await StopScanningAsync(); });
}
else
{
delay = ScanningOptions.DelayBetweenContinuousScans;
}
LastScanResult = result;
ScanCallback(result);
}
processing = false;
timerPreview.Change(delay, Timeout.Infinite);
}, null, ScanningOptions.InitialDelayBeforeAnalyzingFrames, Timeout.Infinite);
}
public async Task StartScanningAsync(Action <ZXing.Result> scanCallback, MobileBarcodeScanningOptions options = null)
{
if (stopping)
{
return;
}
isAnalyzing = true;
ScanCallback = scanCallback;
ScanningOptions = options ?? MobileBarcodeScanningOptions.Default;
topText.Text = TopText ?? string.Empty;
bottomText.Text = BottomText ?? string.Empty;
if (UseCustomOverlay)
{
gridCustomOverlay.Children.Clear();
if (CustomOverlay != null)
{
gridCustomOverlay.Children.Add(CustomOverlay);
}
gridCustomOverlay.Visibility = Visibility.Visible;
gridDefaultOverlay.Visibility = Visibility.Collapsed;
}
else
{
gridCustomOverlay.Visibility = Visibility.Collapsed;
gridDefaultOverlay.Visibility = Visibility.Visible;
}
// Find which device to use
var preferredCamera = await this.GetFilteredCameraOrDefaultAsync(ScanningOptions);
mediaCapture = new MediaCapture();
// Initialize the capture with the settings above
await mediaCapture.InitializeAsync(new MediaCaptureInitializationSettings()
{
StreamingCaptureMode = StreamingCaptureMode.Video,
VideoDeviceId = preferredCamera.Id
});
// Set the capture element's source to show it in the UI
captureElement.Source = mediaCapture;
// Start the preview
await mediaCapture.StartPreviewAsync();
// Get all the available resolutions for preview
var availableProperties = mediaCapture.VideoDeviceController.GetAvailableMediaStreamProperties(MediaStreamType.VideoPreview);
var availableResolutions = new List <CameraResolution>();
foreach (var ap in availableProperties)
{
var vp = (VideoEncodingProperties)ap;
System.Diagnostics.Debug.WriteLine("Camera Preview Resolution: {0}x{1}", vp.Width, vp.Height);
availableResolutions.Add(new CameraResolution {
Width = (int)vp.Width, Height = (int)vp.Height
});
}
CameraResolution previewResolution = null;
if (ScanningOptions.CameraResolutionSelector != null)
{
previewResolution = ScanningOptions.CameraResolutionSelector(availableResolutions);
}
// If the user did not specify a resolution, let's try and find a suitable one
if (previewResolution == null)
{
// Loop through all supported sizes
foreach (var sps in availableResolutions)
{
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000)
{
previewResolution = new CameraResolution
{
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
if (previewResolution == null)
{
previewResolution = availableResolutions.LastOrDefault();
}
System.Diagnostics.Debug.WriteLine("Using Preview Resolution: {0}x{1}", previewResolution.Width, previewResolution.Height);
// Find the matching property based on the selection, again
var chosenProp = availableProperties.FirstOrDefault(ap => ((VideoEncodingProperties)ap).Width == previewResolution.Width && ((VideoEncodingProperties)ap).Height == previewResolution.Height);
// Set the selected resolution
await mediaCapture.VideoDeviceController.SetMediaStreamPropertiesAsync(MediaStreamType.VideoPreview, chosenProp);
await SetPreviewRotationAsync();
captureElement.Stretch = Stretch.UniformToFill;
// Get our preview properties
var previewProperties = mediaCapture.VideoDeviceController.GetMediaStreamProperties(MediaStreamType.VideoPreview) as VideoEncodingProperties;
// Setup a frame to use as the input settings
var destFrame = new VideoFrame(Windows.Graphics.Imaging.BitmapPixelFormat.Bgra8, (int)previewProperties.Width, (int)previewProperties.Height);
var zxing = ScanningOptions.BuildBarcodeReader();
timerPreview = new Timer(async(state) => {
var delay = ScanningOptions.DelayBetweenAnalyzingFrames;
if (stopping || processing || !isAnalyzing ||
(mediaCapture == null || mediaCapture.CameraStreamState != Windows.Media.Devices.CameraStreamState.Streaming))
{
timerPreview.Change(delay, Timeout.Infinite);
return;
}
processing = true;
SoftwareBitmapLuminanceSource luminanceSource = null;
try
{
// Get preview
var frame = await mediaCapture.GetPreviewFrameAsync(destFrame);
// Create our luminance source
luminanceSource = new SoftwareBitmapLuminanceSource(frame.SoftwareBitmap);
} catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("GetPreviewFrame Failed: {0}", ex);
}
ZXing.Result result = null;
try
{
// Try decoding the image
if (luminanceSource != null)
{
result = zxing.Decode(luminanceSource);
}
}
catch (Exception ex)
{
}
// Check if a result was found
if (result != null && !string.IsNullOrEmpty(result.Text))
{
if (!ContinuousScanning)
{
delay = Timeout.Infinite;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { await StopScanningAsync(); });
}
else
{
delay = ScanningOptions.DelayBetweenContinuousScans;
}
LastScanResult = result;
ScanCallback(result);
}
processing = false;
timerPreview.Change(delay, Timeout.Infinite);
}, null, ScanningOptions.InitialDelayBeforeAnalyzingFrames, Timeout.Infinite);
}
public void SurfaceChanged(ISurfaceHolder holder, Format format, int w, int h)
{
if (camera == null)
{
return;
}
var perf = PerformanceCounter.Start();
var parameters = camera.GetParameters();
parameters.PreviewFormat = ImageFormatType.Nv21;
var availableResolutions = new List <CameraResolution> ();
foreach (var sps in parameters.SupportedPreviewSizes)
{
availableResolutions.Add(new CameraResolution {
Width = sps.Width,
Height = sps.Height
});
}
// Try and get a desired resolution from the options selector
var resolution = options.GetResolution(availableResolutions);
// If the user did not specify a resolution, let's try and find a suitable one
if (resolution == null)
{
// Loop through all supported sizes
foreach (var sps in parameters.SupportedPreviewSizes)
{
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000)
{
resolution = new CameraResolution {
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
// Google Glass requires this fix to display the camera output correctly
if (Build.Model.Contains("Glass"))
{
resolution = new CameraResolution {
Width = 640,
Height = 360
};
// Glass requires 30fps
parameters.SetPreviewFpsRange(30000, 30000);
}
// Hopefully a resolution was selected at some point
if (resolution != null)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Selected Resolution: " + resolution.Width + "x" + resolution.Height);
parameters.SetPreviewSize(resolution.Width, resolution.Height);
}
camera.SetParameters(parameters);
SetCameraDisplayOrientation(this.activity);
camera.SetPreviewDisplay(holder);
camera.StartPreview();
//cameraResolution = new Size(parameters.PreviewSize.Width, parameters.PreviewSize.Height);
PerformanceCounter.Stop(perf, "SurfaceChanged took {0}ms");
AutoFocus();
}
bool SetupCaptureSession()
{
var started = DateTime.UtcNow;
var availableResolutions = new List <CameraResolution>();
var consideredResolutions = new Dictionary <NSString, CameraResolution> {
{ AVCaptureSession.Preset352x288, new CameraResolution {
Width = 352, Height = 288
} },
{ AVCaptureSession.PresetMedium, new CameraResolution {
Width = 480, Height = 360
} }, //480x360
{ AVCaptureSession.Preset640x480, new CameraResolution {
Width = 640, Height = 480
} },
{ AVCaptureSession.Preset1280x720, new CameraResolution {
Width = 1280, Height = 720
} },
{ AVCaptureSession.Preset1920x1080, new CameraResolution {
Width = 1920, Height = 1080
} }
};
// configure the capture session for low resolution, change this if your code
// can cope with more data or volume
session = new AVCaptureSession()
{
SessionPreset = AVCaptureSession.Preset640x480
};
// create a device input and attach it to the session
var devices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
foreach (var device in devices)
{
captureDevice = device;
if (ScanningOptions.UseFrontCameraIfAvailable.HasValue &&
ScanningOptions.UseFrontCameraIfAvailable.Value &&
device.Position == AVCaptureDevicePosition.Front)
{
break; //Front camera successfully set
}
else if (device.Position == AVCaptureDevicePosition.Back && (!ScanningOptions.UseFrontCameraIfAvailable.HasValue || !ScanningOptions.UseFrontCameraIfAvailable.Value))
{
break; //Back camera succesfully set
}
}
if (captureDevice == null)
{
Console.WriteLine("No captureDevice - this won't work on the simulator, try a physical device");
if (overlayView != null)
{
AddSubview(overlayView);
BringSubviewToFront(overlayView);
}
return(false);
}
CameraResolution resolution = null;
// Find resolution
// Go through the resolutions we can even consider
foreach (var cr in consideredResolutions)
{
// Now check to make sure our selected device supports the resolution
// so we can add it to the list to pick from
if (captureDevice.SupportsAVCaptureSessionPreset(cr.Key))
{
availableResolutions.Add(cr.Value);
}
}
resolution = ScanningOptions.GetResolution(availableResolutions);
// See if the user selected a resolution
if (resolution != null)
{
// Now get the preset string from the resolution chosen
var preset = (from c in consideredResolutions
where c.Value.Width == resolution.Width &&
c.Value.Height == resolution.Height
select c.Key).FirstOrDefault();
// If we found a matching preset, let's set it on the session
if (!string.IsNullOrEmpty(preset))
{
session.SessionPreset = preset;
}
}
var input = AVCaptureDeviceInput.FromDevice(captureDevice);
if (input == null)
{
Console.WriteLine("No input - this won't work on the simulator, try a physical device");
if (overlayView != null)
{
AddSubview(overlayView);
BringSubviewToFront(overlayView);
}
return(false);
}
else
{
session.AddInput(input);
}
var startedAVPreviewLayerAlloc = PerformanceCounter.Start();
previewLayer = new AVCaptureVideoPreviewLayer(session);
PerformanceCounter.Stop(startedAVPreviewLayerAlloc, "Alloc AVCaptureVideoPreviewLayer took {0} ms.");
var perf2 = PerformanceCounter.Start();
previewLayer.VideoGravity = AVLayerVideoGravity.ResizeAspectFill;
previewLayer.Frame = new CGRect(0, 0, Frame.Width, Frame.Height);
previewLayer.Position = new CGPoint(Layer.Bounds.Width / 2, (Layer.Bounds.Height / 2));
layerView = new UIView(new CGRect(0, 0, Frame.Width, Frame.Height));
layerView.AutoresizingMask = UIViewAutoresizing.FlexibleWidth | UIViewAutoresizing.FlexibleHeight;
layerView.Layer.AddSublayer(previewLayer);
AddSubview(layerView);
ResizePreview(UIApplication.SharedApplication.StatusBarOrientation);
if (overlayView != null)
{
AddSubview(overlayView);
BringSubviewToFront(overlayView);
}
PerformanceCounter.Stop(perf2, "PERF: Setting up layers took {0} ms");
var perf3 = PerformanceCounter.Start();
session.StartRunning();
PerformanceCounter.Stop(perf3, "PERF: session.StartRunning() took {0} ms");
var perf4 = PerformanceCounter.Start();
var videoSettings = NSDictionary.FromObjectAndKey(new NSNumber((int)CVPixelFormatType.CV32BGRA),
CVPixelBuffer.PixelFormatTypeKey);
// create a VideoDataOutput and add it to the sesion
output = new AVCaptureVideoDataOutput
{
WeakVideoSettings = videoSettings
};
// configure the output
queue = new DispatchQueue("ZxingScannerView"); // (Guid.NewGuid().ToString());
var barcodeReader = ScanningOptions.BuildBarcodeReader();
outputRecorder = new OutputRecorder(this, img =>
{
var ls = img;
if (!IsAnalyzing)
{
return(false);
}
try
{
var perfDecode = PerformanceCounter.Start();
if (shouldRotatePreviewBuffer)
{
ls = ls.rotateCounterClockwise();
}
var result = barcodeReader.Decode(ls);
PerformanceCounter.Stop(perfDecode, "Decode Time: {0} ms");
if (result != null)
{
resultCallback(new ScanResult(result, null));
return(true);
}
}
catch (Exception ex)
{
Console.WriteLine("DECODE FAILED: " + ex);
}
return(false);
});
output.AlwaysDiscardsLateVideoFrames = true;
output.SetSampleBufferDelegate(outputRecorder, queue);
PerformanceCounter.Stop(perf4, "PERF: SetupCamera Finished. Took {0} ms.");
session.AddOutput(output);
var perf5 = PerformanceCounter.Start();
if (captureDevice.LockForConfiguration(out var err))
{
captureDeviceOriginalConfig = new AVConfigs
{
FocusMode = captureDevice.FocusMode,
ExposureMode = captureDevice.ExposureMode,
WhiteBalanceMode = captureDevice.WhiteBalanceMode,
AutoFocusRangeRestriction = captureDevice.AutoFocusRangeRestriction,
};
if (captureDevice.HasFlash)
{
captureDeviceOriginalConfig.FlashMode = captureDevice.FlashMode;
}
if (captureDevice.HasTorch)
{
captureDeviceOriginalConfig.TorchMode = captureDevice.TorchMode;
}
if (captureDevice.FocusPointOfInterestSupported)
{
captureDeviceOriginalConfig.FocusPointOfInterest = captureDevice.FocusPointOfInterest;
}
if (captureDevice.ExposurePointOfInterestSupported)
{
captureDeviceOriginalConfig.ExposurePointOfInterest = captureDevice.ExposurePointOfInterest;
}
if (ScanningOptions.DisableAutofocus)
{
captureDevice.FocusMode = AVCaptureFocusMode.Locked;
}
else
{
if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
{
captureDevice.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
}
else if (captureDevice.IsFocusModeSupported(AVCaptureFocusMode.AutoFocus))
{
captureDevice.FocusMode = AVCaptureFocusMode.AutoFocus;
}
}
if (captureDevice.IsExposureModeSupported(AVCaptureExposureMode.ContinuousAutoExposure))
{
captureDevice.ExposureMode = AVCaptureExposureMode.ContinuousAutoExposure;
}
else if (captureDevice.IsExposureModeSupported(AVCaptureExposureMode.AutoExpose))
{
captureDevice.ExposureMode = AVCaptureExposureMode.AutoExpose;
}
if (captureDevice.IsWhiteBalanceModeSupported(AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance))
{
captureDevice.WhiteBalanceMode = AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance;
}
else if (captureDevice.IsWhiteBalanceModeSupported(AVCaptureWhiteBalanceMode.AutoWhiteBalance))
{
captureDevice.WhiteBalanceMode = AVCaptureWhiteBalanceMode.AutoWhiteBalance;
}
if (UIDevice.CurrentDevice.CheckSystemVersion(7, 0) && captureDevice.AutoFocusRangeRestrictionSupported)
{
captureDevice.AutoFocusRangeRestriction = AVCaptureAutoFocusRangeRestriction.Near;
}
if (captureDevice.FocusPointOfInterestSupported)
{
captureDevice.FocusPointOfInterest = new PointF(0.5f, 0.5f);
}
if (captureDevice.ExposurePointOfInterestSupported)
{
captureDevice.ExposurePointOfInterest = new PointF(0.5f, 0.5f);
}
captureDevice.UnlockForConfiguration();
}
else
{
Console.WriteLine("Failed to Lock for Config: " + err.Description);
}
PerformanceCounter.Stop(perf5, "PERF: Setup Focus in {0} ms.");
return(true);
}
public async Task StartScanningAsync(Action<ZXing.Result> scanCallback, MobileBarcodeScanningOptions options = null)
{
if (stopping)
return;
displayRequest.RequestActive();
isAnalyzing = true;
ScanCallback = scanCallback;
ScanningOptions = options ?? MobileBarcodeScanningOptions.Default;
topText.Text = TopText ?? string.Empty;
bottomText.Text = BottomText ?? string.Empty;
if (UseCustomOverlay)
{
gridCustomOverlay.Children.Clear();
if (CustomOverlay != null)
gridCustomOverlay.Children.Add(CustomOverlay);
gridCustomOverlay.Visibility = Visibility.Visible;
gridDefaultOverlay.Visibility = Visibility.Collapsed;
}
else
{
gridCustomOverlay.Visibility = Visibility.Collapsed;
gridDefaultOverlay.Visibility = Visibility.Visible;
}
// Find which device to use
var preferredCamera = await GetFilteredCameraOrDefaultAsync(ScanningOptions);
if (preferredCamera == null)
{
System.Diagnostics.Debug.WriteLine("No camera available");
isMediaCaptureInitialized = false;
return;
}
if (preferredCamera.EnclosureLocation == null || preferredCamera.EnclosureLocation.Panel == Windows.Devices.Enumeration.Panel.Unknown)
{
// No information on the location of the camera, assume it's an external camera, not integrated on the device.
externalCamera = true;
}
else
{
// Camera is fixed on the device.
externalCamera = false;
// Only mirror the preview if the camera is on the front panel.
mirroringPreview = preferredCamera.EnclosureLocation.Panel == Windows.Devices.Enumeration.Panel.Front;
}
mediaCapture = new MediaCapture();
// Initialize the capture with the settings above
try
{
await mediaCapture.InitializeAsync(new MediaCaptureInitializationSettings
{
StreamingCaptureMode = StreamingCaptureMode.Video,
VideoDeviceId = preferredCamera.Id
});
isMediaCaptureInitialized = true;
}
catch (UnauthorizedAccessException)
{
System.Diagnostics.Debug.WriteLine("Denied access to the camera");
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Exception when init MediaCapture: {0}", ex);
}
if (!isMediaCaptureInitialized)
return;
// Set the capture element's source to show it in the UI
captureElement.Source = mediaCapture;
// Start the preview
await mediaCapture.StartPreviewAsync();
// Get all the available resolutions for preview
var availableProperties = mediaCapture.VideoDeviceController.GetAvailableMediaStreamProperties(MediaStreamType.VideoPreview);
var availableResolutions = new List<CameraResolution>();
foreach (var ap in availableProperties)
{
var vp = (VideoEncodingProperties)ap;
System.Diagnostics.Debug.WriteLine("Camera Preview Resolution: {0}x{1}", vp.Width, vp.Height);
availableResolutions.Add(new CameraResolution { Width = (int)vp.Width, Height = (int)vp.Height });
}
CameraResolution previewResolution = null;
if (ScanningOptions.CameraResolutionSelector != null)
previewResolution = ScanningOptions.CameraResolutionSelector(availableResolutions);
// If the user did not specify a resolution, let's try and find a suitable one
if (previewResolution == null)
{
// Loop through all supported sizes
foreach (var sps in availableResolutions)
{
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000)
{
previewResolution = new CameraResolution
{
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
if (previewResolution == null)
previewResolution = availableResolutions.LastOrDefault();
MobileBarcodeScanner.Log("Using Preview Resolution: {0}x{1}", previewResolution.Width, previewResolution.Height);
// Find the matching property based on the selection, again
var chosenProp = availableProperties.FirstOrDefault(ap => ((VideoEncodingProperties)ap).Width == previewResolution.Width && ((VideoEncodingProperties)ap).Height == previewResolution.Height);
// Pass in the requested preview size properties
// so we can set them at the same time as the preview rotation
// to save an additional set property call
await SetPreviewRotationAsync(chosenProp);
// *after* the preview is setup, set this so that the UI layout happens
// otherwise the preview gets stuck in a funny place on screen
captureElement.Stretch = Stretch.UniformToFill;
await SetupAutoFocus();
var zxing = ScanningOptions.BuildBarcodeReader();
timerPreview = new Timer(async (state) => {
var delay = ScanningOptions.DelayBetweenAnalyzingFrames;
if (stopping || processing || !isAnalyzing
|| (mediaCapture == null || mediaCapture.CameraStreamState != Windows.Media.Devices.CameraStreamState.Streaming))
{
timerPreview.Change(delay, Timeout.Infinite);
return;
}
processing = true;
SoftwareBitmapLuminanceSource luminanceSource = null;
try
{
// Get preview
var frame = await mediaCapture.GetPreviewFrameAsync(videoFrame);
// Create our luminance source
luminanceSource = new SoftwareBitmapLuminanceSource(frame.SoftwareBitmap);
} catch (Exception ex)
{
MobileBarcodeScanner.Log ("GetPreviewFrame Failed: {0}", ex);
}
ZXing.Result result = null;
try
{
// Try decoding the image
if (luminanceSource != null)
result = zxing.Decode(luminanceSource);
}
catch (Exception ex)
{
MobileBarcodeScanner.Log("Warning: zxing.Decode Failed: {0}", ex);
}
// Check if a result was found
if (result != null && !string.IsNullOrEmpty (result.Text))
{
if (!ContinuousScanning)
{
delay = Timeout.Infinite;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () => { await StopScanningAsync(); });
}
else
{
delay = ScanningOptions.DelayBetweenContinuousScans;
}
LastScanResult = result;
ScanCallback(result);
}
processing = false;
timerPreview.Change(delay, Timeout.Infinite);
}, null, ScanningOptions.InitialDelayBeforeAnalyzingFrames, Timeout.Infinite);
}
public async Task StartScanningAsync (Action<Result> scanResultCallback, MobileBarcodeScanningOptions options = null)
{
this.callback = scanResultCallback;
this.scanningOptions = options ?? MobileBarcodeScanningOptions.Default;
lastPreviewAnalysis = DateTime.UtcNow.AddMilliseconds (this.scanningOptions.InitialDelayBeforeAnalyzingFrames);
isAnalyzing = true;
Console.WriteLine ("StartScanning");
CheckCameraPermissions ();
var perf = PerformanceCounter.Start ();
GetExclusiveAccess ();
try {
var version = Build.VERSION.SdkInt;
if (version >= BuildVersionCodes.Gingerbread) {
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Checking Number of cameras...");
var numCameras = Camera.NumberOfCameras;
var camInfo = new Camera.CameraInfo ();
var found = false;
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Found " + numCameras + " cameras...");
var whichCamera = CameraFacing.Back;
if (this.scanningOptions.UseFrontCameraIfAvailable.HasValue && this.scanningOptions.UseFrontCameraIfAvailable.Value)
whichCamera = CameraFacing.Front;
for (int i = 0; i < numCameras; i++) {
Camera.GetCameraInfo (i, camInfo);
if (camInfo.Facing == whichCamera) {
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Found " + whichCamera + " Camera, opening...");
camera = Camera.Open (i);
cameraId = i;
found = true;
break;
}
}
if (!found) {
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Finding " + whichCamera + " camera failed, opening camera 0...");
camera = Camera.Open (0);
cameraId = 0;
}
} else {
camera = Camera.Open ();
}
if (camera == null)
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Camera is null :(");
camera.SetPreviewCallback (this);
} catch (Exception ex) {
ShutdownCamera ();
Console.WriteLine ("Setup Error: " + ex);
}
PerformanceCounter.Stop (perf, "Camera took {0}ms");
if (!surfaceChanged)
await waitSurface.WaitAsync ();
if (camera == null)
return;
perf = PerformanceCounter.Start ();
var parameters = camera.GetParameters ();
parameters.PreviewFormat = ImageFormatType.Nv21;
var availableResolutions = new List<CameraResolution> ();
foreach (var sps in parameters.SupportedPreviewSizes) {
availableResolutions.Add (new CameraResolution {
Width = sps.Width,
Height = sps.Height
});
}
// Try and get a desired resolution from the options selector
var resolution = scanningOptions.GetResolution (availableResolutions);
// If the user did not specify a resolution, let's try and find a suitable one
if (resolution == null) {
// Loop through all supported sizes
foreach (var sps in parameters.SupportedPreviewSizes) {
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000) {
resolution = new CameraResolution {
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
// Google Glass requires this fix to display the camera output correctly
if (Build.Model.Contains ("Glass")) {
resolution = new CameraResolution {
Width = 640,
Height = 360
};
// Glass requires 30fps
parameters.SetPreviewFpsRange (30000, 30000);
}
// Hopefully a resolution was selected at some point
if (resolution != null) {
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Selected Resolution: " + resolution.Width + "x" + resolution.Height);
parameters.SetPreviewSize (resolution.Width, resolution.Height);
}
camera.SetParameters (parameters);
SetCameraDisplayOrientation (this.activity);
camera.SetPreviewDisplay (this.Holder);
camera.StartPreview ();
PerformanceCounter.Stop (perf, "SurfaceChanged took {0}ms");
AutoFocus ();
}
async Task SetupCamera()
{
if (camera != null)
{
return;
}
await tcsSurfaceReady.Task;
lastPreviewAnalysis = DateTime.UtcNow.AddMilliseconds(this.scanningOptions.InitialDelayBeforeAnalyzingFrames);
isAnalyzing = true;
CheckCameraPermissions();
var perf = PerformanceCounter.Start();
GetExclusiveAccess();
try {
var version = Build.VERSION.SdkInt;
if (version >= BuildVersionCodes.Gingerbread)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Checking Number of cameras...");
var numCameras = Camera.NumberOfCameras;
var camInfo = new Camera.CameraInfo();
var found = false;
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Found " + numCameras + " cameras...");
var whichCamera = CameraFacing.Back;
if (this.scanningOptions.UseFrontCameraIfAvailable.HasValue && this.scanningOptions.UseFrontCameraIfAvailable.Value)
{
whichCamera = CameraFacing.Front;
}
for (int i = 0; i < numCameras; i++)
{
Camera.GetCameraInfo(i, camInfo);
if (camInfo.Facing == whichCamera)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Found " + whichCamera + " Camera, opening...");
camera = Camera.Open(i);
cameraId = i;
found = true;
break;
}
}
if (!found)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Finding " + whichCamera + " camera failed, opening camera 0...");
camera = Camera.Open(0);
cameraId = 0;
}
}
else
{
camera = Camera.Open();
}
if (camera != null)
{
camera.SetPreviewCallback(this);
}
else
{
MobileBarcodeScanner.LogWarn(MobileBarcodeScanner.TAG, "Camera is null :(");
return;
}
} catch (Exception ex) {
ShutdownCamera();
MobileBarcodeScanner.LogError("Setup Error: {0}", ex);
return;
}
PerformanceCounter.Stop(perf, "Setup Camera took {0}ms");
perf = PerformanceCounter.Start();
var parameters = camera.GetParameters();
parameters.PreviewFormat = ImageFormatType.Nv21;
// First try continuous video, then auto focus, then fixed
var supportedFocusModes = parameters.SupportedFocusModes;
if (Build.VERSION.SdkInt >= BuildVersionCodes.IceCreamSandwich &&
supportedFocusModes.Contains(Camera.Parameters.FocusModeContinuousPicture))
{
parameters.FocusMode = Camera.Parameters.FocusModeContinuousPicture;
}
else if (supportedFocusModes.Contains(Camera.Parameters.FocusModeContinuousVideo))
{
parameters.FocusMode = Camera.Parameters.FocusModeContinuousVideo;
}
else if (supportedFocusModes.Contains(Camera.Parameters.FocusModeAuto))
{
parameters.FocusMode = Camera.Parameters.FocusModeAuto;
}
else if (supportedFocusModes.Contains(Camera.Parameters.FocusModeFixed))
{
parameters.FocusMode = Camera.Parameters.FocusModeFixed;
}
var selectedFps = parameters.SupportedPreviewFpsRange.FirstOrDefault();
if (selectedFps != null)
{
// This will make sure we select a range with the lowest minimum FPS
// and maximum FPS which still has the lowest minimum
// This should help maximize performance / support for hardware
foreach (var fpsRange in parameters.SupportedPreviewFpsRange)
{
if (fpsRange [0] <= selectedFps [0] &&
fpsRange [1] > selectedFps [1])
{
selectedFps = fpsRange;
}
}
parameters.SetPreviewFpsRange(selectedFps [0], selectedFps [1]);
}
var availableResolutions = new List <CameraResolution> ();
foreach (var sps in parameters.SupportedPreviewSizes)
{
availableResolutions.Add(new CameraResolution {
Width = sps.Width,
Height = sps.Height
});
}
// Try and get a desired resolution from the options selector
var resolution = scanningOptions.GetResolution(availableResolutions);
// If the user did not specify a resolution, let's try and find a suitable one
if (resolution == null)
{
// Loop through all supported sizes
foreach (var sps in parameters.SupportedPreviewSizes)
{
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000)
{
resolution = new CameraResolution {
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
// Google Glass requires this fix to display the camera output correctly
if (Build.Model.Contains("Glass"))
{
resolution = new CameraResolution {
Width = 640,
Height = 360
};
// Glass requires 30fps
parameters.SetPreviewFpsRange(30000, 30000);
}
// Hopefully a resolution was selected at some point
if (resolution != null)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Selected Resolution: " + resolution.Width + "x" + resolution.Height);
parameters.SetPreviewSize(resolution.Width, resolution.Height);
}
camera.SetParameters(parameters);
SetCameraDisplayOrientation(this.activity);
camera.SetPreviewDisplay(this.Holder);
camera.StartPreview();
PerformanceCounter.Stop(perf, "Setup Camera Parameters took {0}ms");
// Docs suggest if Auto or Macro modes, we should invoke AutoFocus at least once
var currentFocusMode = camera.GetParameters().FocusMode;
if (currentFocusMode == Camera.Parameters.FocusModeAuto ||
currentFocusMode == Camera.Parameters.FocusModeMacro)
{
AutoFocus();
}
}
async Task SetupCamera ()
{
if (camera != null)
return;
await tcsSurfaceReady.Task;
lastPreviewAnalysis = DateTime.UtcNow.AddMilliseconds (this.scanningOptions.InitialDelayBeforeAnalyzingFrames);
isAnalyzing = true;
CheckCameraPermissions ();
var perf = PerformanceCounter.Start ();
GetExclusiveAccess ();
try {
var version = Build.VERSION.SdkInt;
if (version >= BuildVersionCodes.Gingerbread) {
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Checking Number of cameras...");
var numCameras = Camera.NumberOfCameras;
var camInfo = new Camera.CameraInfo ();
var found = false;
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Found " + numCameras + " cameras...");
var whichCamera = CameraFacing.Back;
if (this.scanningOptions.UseFrontCameraIfAvailable.HasValue && this.scanningOptions.UseFrontCameraIfAvailable.Value)
whichCamera = CameraFacing.Front;
for (int i = 0; i < numCameras; i++) {
Camera.GetCameraInfo (i, camInfo);
if (camInfo.Facing == whichCamera) {
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Found " + whichCamera + " Camera, opening...");
camera = Camera.Open (i);
cameraId = i;
found = true;
break;
}
}
if (!found) {
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Finding " + whichCamera + " camera failed, opening camera 0...");
camera = Camera.Open (0);
cameraId = 0;
}
} else {
camera = Camera.Open ();
}
if (camera != null)
camera.SetPreviewCallback (this);
else {
MobileBarcodeScanner.LogWarn (MobileBarcodeScanner.TAG, "Camera is null :(");
return;
}
} catch (Exception ex) {
ShutdownCamera ();
MobileBarcodeScanner.LogError ("Setup Error: {0}", ex);
return;
}
PerformanceCounter.Stop (perf, "Setup Camera took {0}ms");
perf = PerformanceCounter.Start ();
var parameters = camera.GetParameters ();
parameters.PreviewFormat = ImageFormatType.Nv21;
// First try continuous video, then auto focus, then fixed
var supportedFocusModes = parameters.SupportedFocusModes;
if (supportedFocusModes.Contains (Camera.Parameters.FocusModeAuto))
parameters.FocusMode = Camera.Parameters.FocusModeAuto;
else if (supportedFocusModes.Contains (Camera.Parameters.FocusModeContinuousVideo))
parameters.FocusMode = Camera.Parameters.FocusModeContinuousVideo;
else if (supportedFocusModes.Contains (Camera.Parameters.FocusModeFixed))
parameters.FocusMode = Camera.Parameters.FocusModeFixed;
var selectedFps = parameters.SupportedPreviewFpsRange.FirstOrDefault ();
if (selectedFps != null) {
// This will make sure we select a range with the lowest minimum FPS
// and maximum FPS which still has the lowest minimum
// This should help maximize performance / support for hardware
foreach (var fpsRange in parameters.SupportedPreviewFpsRange) {
if (fpsRange [0] <= selectedFps [0]
&& fpsRange [1] > selectedFps [1])
selectedFps = fpsRange;
}
parameters.SetPreviewFpsRange (selectedFps [0], selectedFps [1]);
}
var availableResolutions = new List<CameraResolution> ();
foreach (var sps in parameters.SupportedPreviewSizes) {
availableResolutions.Add (new CameraResolution {
Width = sps.Width,
Height = sps.Height
});
}
// Try and get a desired resolution from the options selector
var resolution = scanningOptions.GetResolution (availableResolutions);
// If the user did not specify a resolution, let's try and find a suitable one
if (resolution == null) {
// Loop through all supported sizes
foreach (var sps in parameters.SupportedPreviewSizes) {
// Find one that's >= 640x360 but <= 1000x1000
// This will likely pick the *smallest* size in that range, which should be fine
if (sps.Width >= 640 && sps.Width <= 1000 && sps.Height >= 360 && sps.Height <= 1000) {
resolution = new CameraResolution {
Width = sps.Width,
Height = sps.Height
};
break;
}
}
}
// Google Glass requires this fix to display the camera output correctly
if (Build.Model.Contains ("Glass")) {
resolution = new CameraResolution {
Width = 640,
Height = 360
};
// Glass requires 30fps
parameters.SetPreviewFpsRange (30000, 30000);
}
// Hopefully a resolution was selected at some point
if (resolution != null) {
Android.Util.Log.Debug (MobileBarcodeScanner.TAG, "Selected Resolution: " + resolution.Width + "x" + resolution.Height);
parameters.SetPreviewSize (resolution.Width, resolution.Height);
}
camera.SetParameters (parameters);
SetCameraDisplayOrientation (this.activity);
camera.SetPreviewDisplay (this.Holder);
camera.StartPreview ();
PerformanceCounter.Stop (perf, "Setup Camera Parameters took {0}ms");
// Docs suggest if Auto or Macro modes, we should invoke AutoFocus at least once
var currentFocusMode = camera.GetParameters ().FocusMode;
if (currentFocusMode == Camera.Parameters.FocusModeAuto
|| currentFocusMode == Camera.Parameters.FocusModeMacro)
AutoFocus ();
}
