public void SurfaceCreated(ISurfaceHolder holder)
{
// The Surface has been created, now tell the camera where to draw the preview.
try
{
// _camera.SetPreviewDisplay(holder);
Parameters parameters = _camera.GetParameters();
foreach (var previewSize in _camera.GetParameters().SupportedPreviewSizes)
{
// if the size is suitable for you, use it and exit the loop.
parameters.SetPreviewSize(previewSize.Width, previewSize.Height);
break;
}
_camera.SetParameters(parameters);
_camera.SetPreviewDisplay(_holder);
_camera.StartPreview();
}
catch (IOException e)
{
Log.Debug(Tag.ToString(), "Error setting camera preview: " + e.Message);
}
}
public void SurfaceChanged(ISurfaceHolder holder, [GeneratedEnum] Format format, int width, int height)
{
if (Holder.Surface == null)
{
return;
}
try
{
_camera.StopPreview();
}
catch (Exception)
{
// ignore: tried to stop a non-existent preview
}
try
{
// start preview with new settings
_camera.SetPreviewDisplay(Holder);
_camera.StartPreview();
}
catch (Exception e)
{
Log.Debug("", "Error starting camera preview: " + e.Message);
}
}
public void SetupCamera()
{
if (Camera != null)
{
return;
}
var perf = PerformanceCounter.Start();
OpenCamera();
PerformanceCounter.Stop(perf, "Setup Camera took {0}ms");
if (Camera == null)
{
return;
}
perf = PerformanceCounter.Start();
ApplyCameraSettings();
try
{
Camera.SetPreviewDisplay(holder);
var previewParameters = Camera.GetParameters();
var previewSize = previewParameters.PreviewSize;
var bitsPerPixel = ImageFormat.GetBitsPerPixel(previewParameters.PreviewFormat);
var bufferSize = (previewSize.Width * previewSize.Height * bitsPerPixel) / 8;
const int NUM_PREVIEW_BUFFERS = 5;
for (uint i = 0; i < NUM_PREVIEW_BUFFERS; ++i)
{
using (var buffer = new FastJavaByteArray(bufferSize))
Camera.AddCallbackBuffer(buffer);
}
Camera.StartPreview();
Camera.SetNonMarshalingPreviewCallback(cameraEventListener);
// 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();
}
}
catch (Exception ex)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, ex.ToString());
return;
}
finally
{
PerformanceCounter.Stop(perf, "Setup Camera Parameters took {0}ms");
}
}
//public void RefreshCamera()
//{
// if (_holder == null) return;
// ApplyCameraSettings();
// try
// {
// Camera.SetPreviewDisplay(_holder);
// Camera.StartPreview();
// }
// catch (Exception ex)
// {
// Android.Util.Log.Debug(nameof(CameraController), ex.ToString());
// }
//}
public void SetupCamera(CameraFacing facing)
{
if (Camera != null)
{
return;
}
PermissionsHandler.CheckCameraPermissions(_context);
OpenCamera(facing);
if (Camera == null)
{
return;
}
ApplyCameraSettings();
try
{
Camera.SetPreviewDisplay(_holder);
//var previewParameters = Camera.GetParameters();
//var previewSize = previewParameters.PreviewSize;
//var bitsPerPixel = ImageFormat.GetBitsPerPixel(previewParameters.PreviewFormat);
//int bufferSize = (previewSize.Width * previewSize.Height * bitsPerPixel) / 8;
//const int NUM_PREVIEW_BUFFERS = 5;
//for (uint i = 0; i < NUM_PREVIEW_BUFFERS; ++i)
//{
// using (var buffer = new FastJavaByteArray(bufferSize))
// Camera.AddCallbackBuffer(buffer);
//}
Camera.StartPreview();
// Camera.SetNonMarshalingPreviewCallback(_cameraEventListener);
}
catch (Exception ex)
{
Android.Util.Log.Debug(nameof(CameraController), ex.ToString());
return;
}
// 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();
}
}
public void ShutdownCamera()
{
if (Camera == null)
{
return;
}
// camera release logic takes about 0.005 sec so there is no need in async releasing
var perf = PerformanceCounter.Start();
try
{
try
{
Camera.SetPreviewCallback(null);
Camera.SetPreviewDisplay(null);
Camera.StopPreview();
}
catch (Exception ex)
{
Android.Util.Log.Error(MobileBarcodeScanner.TAG, ex.ToString());
}
Camera.Release();
Camera = null;
}
catch (Exception e)
{
Android.Util.Log.Error(MobileBarcodeScanner.TAG, e.ToString());
}
PerformanceCounter.Stop(perf, "Shutdown camera took {0}ms");
}
private async void EnableCamera(int cameraToSwitch)
{
try
{
_camera = Camera.Open(cameraToSwitch);
_cameraId = cameraToSwitch;
SetPreviewSize(FullScreen);
SetCameraDisplayOrientation(_cameraId);
_camera.SetPreviewDisplay(_holder);
_camera.StartPreview();
}
catch (Exception ex)
{
if (ex.GetType() == typeof(Java.Lang.RuntimeException) && ex.Message == "Fail to connect to camera service")
{
Activity.Finish();
}
else
{
await AppSettings.Logger.Error(ex);
Activity.ShowAlert(new InternalException(LocalizationKeys.CameraSettingError, ex), ToastLength.Short);
}
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
camera = Android.Hardware.Camera.Open();
var paramsCamera = GetCameraParams(camera);
camera.SetParameters(paramsCamera);
camera.SetPreviewDisplay(holder);
camera.StartPreview();
}
public void RefreshCamera()
{
if (holder == null)
{
return;
}
ApplyCameraSettings();
try
{
camera.SetPreviewDisplay(holder);
camera.StartPreview();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.ToString());
}
}
// Attach the camera to the surface holder, configure the camera and start preview
public void setCameraPreviewDisplayAndStartPreview()
{
try
{
camera.SetPreviewDisplay(previewSurfaceHolder);
}
catch (Throwable t)
{
Log.Error(GetString(Resource.String.app_name), "Exception in setPreviewDisplay()", t);
}
configureCameraAndStartPreview(camera);
}
public void SurfaceCreated(ISurfaceHolder holder)
{
CheckPermissions();
try
{
var version = Android.OS.Build.VERSION.SdkInt;
if (version >= BuildVersionCodes.Gingerbread)
{
var numCameras = Android.Hardware.Camera.NumberOfCameras;
var camInfo = new Android.Hardware.Camera.CameraInfo();
var found = false;
for (int i = 0; i < numCameras; i++)
{
Android.Hardware.Camera.GetCameraInfo(i, camInfo);
if (camInfo.Facing == CameraFacing.Back)
{
camera = Android.Hardware.Camera.Open(i);
found = true;
break;
}
}
if (!found)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Finding rear camera failed, opening camera 0...");
camera = Android.Hardware.Camera.Open(0);
}
}
else
{
camera = Android.Hardware.Camera.Open();
}
if (camera == null)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Camera is null :(");
}
//camera = Android.Hardware.Camera.Open ();
camera.SetPreviewDisplay(holder);
camera.SetPreviewCallback(this);
} catch (Exception ex) {
ShutdownCamera();
// TODO: log or otherwise handle this exception
Console.WriteLine("Setup Error: " + ex);
//throw;
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
try {
camera = Android.Hardware.Camera.Open();
camera.SetPreviewDisplay(holder);
camera.SetPreviewCallback(this);
} catch (Exception) {
ShutdownCamera();
// TODO: log or otherwise handle this exception
//throw;
}
}
public void SurfaceCreated (ISurfaceHolder holder)
{
try {
camera = Camera.Open ();
camera.SetPreviewDisplay (holder);
camera.SetPreviewCallback (this);
} catch (Exception e) {
ShutdownCamera ();
// TODO: log or otherwise handle this exception
throw;
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
// The Surface has been created, acquire the camera and tell it where
// to draw the preview.
mCamera = Android.Hardware.Camera.Open(1);
Log.Debug("", "camera opened!!!");
try
{
mCamera.SetPreviewDisplay(holder);
} catch (Java.IO.IOException exception) {
mCamera.Release();
mCamera = null;
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
if (_camera == null)
{
return;
}
try
{
_camera.SetPreviewDisplay(holder);
_camera.StartPreview();
}
catch (Java.IO.IOException ex)
{
AppSettings.Reporter.SendCrash(ex);
Activity.ShowAlert(Localization.Errors.CameraSettingError, ToastLength.Short);
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
try
{
#if __ANDROID_9__
var numCameras = Android.Hardware.Camera.NumberOfCameras;
var camInfo = new Android.Hardware.Camera.CameraInfo();
var found = false;
for (int i = 0; i < numCameras; i++)
{
Android.Hardware.Camera.GetCameraInfo(i, camInfo);
if (camInfo.Facing == CameraFacing.Back)
{
camera = Android.Hardware.Camera.Open(i);
found = true;
break;
}
}
if (!found)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Finding rear camera failed, opening camera 0...");
camera = Android.Hardware.Camera.Open(0);
}
#else
camera = Android.Hardware.Camera.Open();
#endif
if (camera == null)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Camera is null :(");
}
//camera = Android.Hardware.Camera.Open ();
camera.SetPreviewDisplay(holder);
camera.SetPreviewCallback(this);
}
catch (Exception)
{
ShutdownCamera();
// TODO: log or otherwise handle this exception
//throw;
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
try
{
camera.SetPreviewDisplay(holder);
camera.SetDisplayOrientation(90);
camera.SetPreviewCallback(new MyPreviewCallback()
{
v = output
});
camera.StartPreview();
}
catch (Java.IO.IOException e)
{
throw e;
}
}
public void SetupCamera()
{
if (Camera != null)
{
return;
}
ZXing.Net.Mobile.Android.PermissionsHandler.CheckCameraPermissions(_context);
var perf = PerformanceCounter.Start();
OpenCamera();
PerformanceCounter.Stop(perf, "Setup Camera took {0}ms");
if (Camera == null)
{
return;
}
perf = PerformanceCounter.Start();
ApplyCameraSettings();
try
{
Camera.SetPreviewDisplay(_holder);
Camera.StartPreview();
}
catch (Exception ex)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, ex.ToString());
return;
}
finally
{
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();
}
}
private void InitCam()
{
cam.SetDisplayOrientation(90);
cam.SetPreviewDisplay(surfaceView.Holder);
cam.StartPreview();
if (parameters.SupportedFocusModes.Contains(Camera.Parameters.FocusModeContinuousVideo))
{
parameters.FocusMode = Camera.Parameters.FocusModeContinuousVideo;
}
else if (parameters.SupportedFocusModes.Contains(Camera.Parameters.FocusModeMacro))
{
parameters.FocusMode = Camera.Parameters.FocusModeMacro;
}
cam.SetParameters(parameters);
}
public void SurfaceChanged(ISurfaceHolder holder, Format format, int width, int height)
{
try
{
if (previewing)
{
camera.StopPreview();
previewing = false;
}
if (camera != null)
{
camera.SetPreviewDisplay(surfaceHolder);
camera.StartPreview();
previewing = true;
}
}
catch { }
}
public async void SurfaceCreated(ISurfaceHolder holder)
{
if (_camera == null)
{
return;
}
try
{
_camera.SetPreviewDisplay(holder);
_camera.StartPreview();
}
catch (Exception ex)
{
await AppSettings.Logger.Error(ex);
Activity.ShowAlert(new InternalException(LocalizationKeys.CameraSettingError, ex), ToastLength.Short);
}
}
public void RefreshCamera()
{
if (_holder == null)
{
return;
}
ApplyCameraSettings();
try
{
Camera.SetPreviewDisplay(_holder);
Camera.StartPreview();
}
catch (Exception ex)
{
Android.Util.Log.Debug(MobileBarcodeScanner.TAG, ex.ToString());
}
}
private void StartCamera()
{
System.Console.WriteLine("wertk");
GetBestSupportedCameraSize();
try
{
var p = _parameters;
p.PictureFormat = ImageFormatType.Jpeg;
p.JpegQuality = 100;
p.Set("orientation", "portrait");
p.SetRotation(90);
p.SetPictureSize(_bestWidth, _bestHeight);
_camera.SetParameters(p);
_camera.SetPreviewDisplay(_surfaceHolder);
_camera.SetDisplayOrientation(90);
_camera.StartPreview();
}
catch (IOException e)
{
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
Log.Info(TAG, "********surfaceCreated************");
// The Surface has been created, acquire the camera and tell it where
// to draw.
try
{
if (mCamera != null && !mPreviewed)
{
mHolder = holder;
mCamera.SetPreviewDisplay(holder);
mCamera.StartPreview();
mPreviewed = true;
mSurfaceCreated = true;
}
}
catch (IOException exception)
{
Log.Error(TAG, "IOException caused by setPreviewDisplay()", exception);
}
}
public void setCamera(Android.Hardware.Camera camera, int width, int height)
{
mCamera = camera;
if (mCamera != null)
{
mSupportedPreviewSizes = mCamera.GetParameters().SupportedPreviewSizes.ToList();
RequestLayout();
// get Camera parameters
Parameters paramss = mCamera.GetParameters();
paramss.SetPreviewSize(width, height);
List <string> focusModes = paramss.SupportedFocusModes.ToList();
if (focusModes.Contains(Parameters.FocusModeAuto))
{
// set the focus mode
paramss.FocusMode = Parameters.FocusModeAuto;
// set Camera parameters
}
mCamera.SetParameters(paramss);
if (!mPreviewed && mSurfaceCreated)
{
try
{
mCamera.SetPreviewDisplay(mHolder);
mCamera.StartPreview();
mPreviewed = true;
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.PrintStackTrace();
}
}
}
}
public void SurfaceCreated (ISurfaceHolder holder)
{
try
{
#if __ANDROID_9__
var numCameras = Android.Hardware.Camera.NumberOfCameras;
var camInfo = new Android.Hardware.Camera.CameraInfo();
var found = false;
for (int i = 0; i < numCameras; i++)
{
Android.Hardware.Camera.GetCameraInfo(i, camInfo);
if (camInfo.Facing == CameraFacing.Back)
{
camera = Android.Hardware.Camera.Open(i);
found = true;
break;
}
}
if (!found)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Finding rear camera failed, opening camera 0...");
camera = Android.Hardware.Camera.Open(0);
}
#else
camera = Android.Hardware.Camera.Open();
#endif
if (camera == null)
Android.Util.Log.Debug("ZXing.Net.Mobile", "Camera is null :(");
//camera = Android.Hardware.Camera.Open ();
camera.SetPreviewDisplay (holder);
camera.SetPreviewCallback (this);
} catch (Exception ex) {
ShutdownCamera ();
// TODO: log or otherwise handle this exception
Console.WriteLine("Setup Error: " + ex);
//throw;
}
}
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();
}
}
private bool StartPreview(Camera camera)
{
if (camera == null) { return false; }
StopPreview(camera);
// Mark preview as started if surface holder not yet created. We will really start it later
_previewStarted = true;
if (_surfaceHolder == null) { return false; }
camera.SetDisplayOrientation(_displayOrientation);
camera.SetPreviewDisplay(_surfaceHolder);
try { camera.StartPreview(); }
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("StartPreview {0}", ex);
return false;
}
return true;
}
/// <summary>
/// Create the camera and try to set auto focus with flash
/// </summary>
/// <param name="holder"></param>
public void CreateCamera(ISurfaceHolder holder) {
try
{
_camera = Camera.Open();
Camera.Parameters p = _camera.GetParameters();
p.PictureFormat = Android.Graphics.ImageFormatType.Jpeg;
p.JpegQuality = 100;
hasAutoFocus = (p.SupportedFocusModes.Contains(Camera.Parameters.FocusModeAuto));
if (hasAutoFocus)
{
p.FocusMode = Camera.Parameters.FocusModeAuto;
focusReady = true;
}
else if (p.SupportedFocusModes.Contains(Camera.Parameters.FocusModeContinuousPicture))
{
p.FocusMode = Camera.Parameters.FocusModeContinuousPicture;
}
if (p.SupportedFlashModes.Contains(Camera.Parameters.FlashModeOn))
{
p.FlashMode = Camera.Parameters.FlashModeOn;
}
_camera.SetParameters(p);
_camera.SetDisplayOrientation(90);
_camera.SetPreviewCallback(this);
_camera.Lock();
_camera.SetPreviewDisplay(holder);
_camera.StartPreview();
if (hasAutoFocus)
{
Toast.MakeText(this, "Press screen to focus", ToastLength.Long).Show();
}
}
catch (Exception e)
{
}
}
public void SurfaceCreated (ISurfaceHolder holder)
{
try {
Console.WriteLine("Surface created");
camera = Android.Hardware.Camera.Open ();
camera.SetPreviewDisplay (holder);
camera.SetPreviewCallback (this);
Console.WriteLine("Surface Created end");
} catch (Exception) {
ShutdownCamera ();
Console.WriteLine("Exception, shutdown camera");
// TODO: log or otherwise handle this exception
//throw;
}
}
public void SwitchCamera(Camera camera)
{
SetCamera (camera);
try {
camera.SetPreviewDisplay (mHolder);
} catch (IOException exception) {
Log.Error (TAG, "IOException caused by setPreviewDisplay()", exception);
}
Camera.Parameters parameters = camera.GetParameters ();
parameters.SetPreviewSize (mPreviewSize.Width, mPreviewSize.Height);
RequestLayout();
camera.SetParameters (parameters);
}
public void SurfaceCreated(ISurfaceHolder holder)
{
// The Surface has been created, acquire the camera and tell it where
// to draw.
camera = Camera.Open ();
try {
camera.SetPreviewDisplay (holder);
} catch (Exception) {
camera.Release ();
camera = null;
// TODO: add more exception handling logic here
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
CheckPermissions();
var perf = PerformanceCounter.Start();
try
{
var version = Android.OS.Build.VERSION.SdkInt;
if (version >= BuildVersionCodes.Gingerbread)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Checking Number of cameras...");
var numCameras = Android.Hardware.Camera.NumberOfCameras;
var camInfo = new Android.Hardware.Camera.CameraInfo();
var found = false;
Android.Util.Log.Debug("ZXing.Net.Mobile", "Found " + numCameras + " cameras...");
var whichCamera = CameraFacing.Back;
if (options.UseFrontCameraIfAvailable.HasValue && options.UseFrontCameraIfAvailable.Value)
{
whichCamera = CameraFacing.Front;
}
for (int i = 0; i < numCameras; i++)
{
Android.Hardware.Camera.GetCameraInfo(i, camInfo);
if (camInfo.Facing == whichCamera)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Found " + whichCamera + " Camera, opening...");
camera = Android.Hardware.Camera.Open(i);
found = true;
break;
}
}
if (!found)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Finding " + whichCamera + " camera failed, opening camera 0...");
camera = Android.Hardware.Camera.Open(0);
}
}
else
{
camera = Android.Hardware.Camera.Open();
}
if (camera == null)
{
Android.Util.Log.Debug("ZXing.Net.Mobile", "Camera is null :(");
}
//camera = Android.Hardware.Camera.Open ();
camera.SetPreviewDisplay(holder);
camera.SetPreviewCallback(this);
}
catch (Exception ex)
{
ShutdownCamera();
// TODO: log or otherwise handle this exception
Console.WriteLine("Setup Error: " + ex);
//throw;
}
PerformanceCounter.Stop(perf, "SurfaceCreated took {0}ms");
}
private bool CreateCamera(int cameraIndex)
{
#if !DEBUG
try
#endif
{
StopCamera();
_camera = Camera.Open(cameraIndex);
_camera.SetPreviewDisplay(_surfaceHolder);
if (OnCameraCreated != null)
{
if (_cameraInfo == null)
_cameraInfo = new Android.Hardware.Camera.CameraInfo();
Camera.GetCameraInfo(cameraIndex, _cameraInfo);
OnCameraCreated(this, new CameraInfoEventArgs(_camera, _cameraInfo));
}
}
#if !DEBUG
catch (Exception excpt)
{
_camera.Release();
_camera = null;
while (excpt.InnerException != null)
excpt = excpt.InnerException;
Report.Error(Context.PackageName, String.Format("Unable to create camera: {0}", excpt.Message));
return false;
// TODO: add more exception handling logic here
}
#endif
return true;
}
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());
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
camera.SetPreviewDisplay(holder);
camera.StartPreview();
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
Window.SetFormat(Format.Translucent);
RequestWindowFeature(WindowFeatures.NoTitle);
Window.SetFlags(WindowManagerFlags.Fullscreen, WindowManagerFlags.Fullscreen);
fmanager = FragmentManager;
Window.SetBackgroundDrawable(new ColorDrawable(Color.Black));
Bundle extras = Intent.Extras;
if (extras != null)
{
TrophyName = extras.GetString("TrophyName");
}
trophyFragment = TrophyFragment.newInstance(TrophyName, this);
//trophyFragment.SetStyle(DialogFragmentStyle.Normal, Resource.Style.AppThemepp);
trophyFragment.Show(fmanager, "fragment_edit_name");
trophyFragment.Cancelable = false;
trophyFragment.OnCAptureClick += (Bitmap obj, LinearLayout linearButton) => {
if (obj != null)
{
try
{
bitmaptrophy = obj;
mCamera.TakePicture(null, null, mPreview);
}
catch (System.Exception ex)
{
trophyFragment.progressBarLL.Visibility = ViewStates.Gone;
System.Console.WriteLine("Take Picture Exception:" + ex.ToString());
}
}
};
trophyFragment.ResetAcitivity += (bool obj) => {
System.GC.Collect();
};
trophyFragment.BackPressEvent += (bool obj) => {
trophyFragment.Dismiss();
Finish();
};
trophyFragment.ChangeCameraFace += (bool obj) => {
if (previewing)
{
mCamera.StopPreview();
}
//NB: if you don't release the current camera before switching, you app will crash
mCamera.Release();
//swap the id of the camera to be used
if (currentCameraId == Android.Hardware.Camera.CameraInfo.CameraFacingBack)
{
currentCameraId = Android.Hardware.Camera.CameraInfo.CameraFacingFront;
IsFrontCamera = true;
}
else
{
currentCameraId = Android.Hardware.Camera.CameraInfo.CameraFacingBack;
IsFrontCamera = false;
}
mCamera = Android.Hardware.Camera.Open((int)currentCameraId);
SetCameraDisplayOrientation(this, (int)currentCameraId, mCamera);
try
{
mCamera.SetPreviewDisplay(mPreview.mHolder);
}
catch (System.Exception exx)
{
System.Console.WriteLine("Exception Changeing Camera:" + exx.ToString());
}
//Android.Hardware.Camera.Parameters parameters = mCamera.GetParameters();
//parameters.SetPreviewSize(mPreview.mPreviewSize.Width, mPreview.mPreviewSize.Height);
//System.Console.WriteLine("Param mPreviewSize.Width:" + mPreview.mPreviewSize.Width + " mPreviewSize.height:" + mPreview.mPreviewSize.Height);
//parameters.SetPictureSize(mPreview.mPreviewSize.Width, mPreview.mPreviewSize.Height);
//parameters.JpegQuality = (100);
//parameters.PictureFormat = (ImageFormat.Jpeg);
//parameters.FocusMode = Android.Hardware.Camera.Parameters.FocusModeAuto;
//if (parameters.IsZoomSupported)
// parameters.Zoom = (0);
//mCamera.SetParameters(parameters);
//mCamera.StartPreview();
previewing = false;
mPreview.Dispose();
mPreview = new Preview(this);
SetContentView(mPreview);
mPreview.PreviewCamera = mCamera;
};
//numberOfCameras = Android.Hardware.Camera.NumberOfCameras;
//// Find the ID of the default camera
//Android.Hardware.Camera.CameraInfo cameraInfo = new Android.Hardware.Camera.CameraInfo();
//for (int i = 0; i < numberOfCameras; i++)
//{
// Android.Hardware.Camera.GetCameraInfo(i, cameraInfo);
// if (cameraInfo.Facing == CameraFacing.Back)
// {
// defaultCameraId = i;
// }
//}
}
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();
}
void OnSurfaceChanged()
{
surfaceChanged = true;
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 = 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");
// Reset cancel token source so we can do things like autofocus
autoFocusTokenCancelSrc = new CancellationTokenSource();
AutoFocus();
}
