// Sets up member variables related to camera.
private void SetUpCameraOutputs(int width, int height)
{
CameraManager manager = (CameraManager)Activity.GetSystemService(Context.CameraService);
try
{
foreach (string cameraId in manager.GetCameraIdList())
{
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(cameraId);
Integer facing = (Integer)characteristics.Get(CameraCharacteristics.LensFacing);
if (facing != null && facing == (Integer.ValueOf((int)LensFacing.Front)))
{
continue;
}
StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
if (map == null)
{
continue;
}
// For still image captures, we use the largest available size.
Size largest = (Size)Collections.Max(Arrays.AsList(map.GetOutputSizes((int)ImageFormatType.Jpeg)),
new CompareSizesByArea());
_imageReader = ImageReader.NewInstance(largest.Width, largest.Height, ImageFormatType.Jpeg, 2);
_imageReader.SetOnImageAvailableListener(OnImageAvailableListener, BackgroundHandler);
_sensorOrientation = (int)characteristics.Get(CameraCharacteristics.SensorOrientation);
bool swapped = IsCameraRoationSameAsDevice(Activity.WindowManager.DefaultDisplay.Rotation, _sensorOrientation);
Size rotatedSize = GetRotatedPreviewSize(width, height, swapped);
Size maxSize = GetMaxPrieviewSize(width, height, swapped);
// Danger, W.R.! Attempting to use too large a preview size could exceed the camera
// bus' bandwidth limitation, resulting in gorgeous previews but the storage of
// garbage capture data.
_previewSize = ChooseOptimalSize(map.GetOutputSizes(Class.FromType(typeof(SurfaceTexture))),
rotatedSize.Width, rotatedSize.Height, maxSize.Width,
maxSize.Height, largest);
SetTextureViewAspectRatio();
// Check if the flash is supported.
Boolean available = (Boolean)characteristics.Get(CameraCharacteristics.FlashInfoAvailable);
_flashSupported = (available == null ? false : (bool)available);
_cameraId = cameraId;
return;
}
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
catch//camera_error
{
ErrorDialog.NewInstance(GetString(Resource.String.camera_error)).Show(ChildFragmentManager, FRAGMENT_DIALOG);
}
}
public void ChangeZoom(float zoomLevel)
{
Activity activity = (Activity)context;
var manager = (CameraManager)context.GetSystemService(Context.CameraService);
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(mCameraId);
float maxzoom = ((int)characteristics.Get(CameraCharacteristics.ScalerAvailableMaxDigitalZoom)) * 10;
Rect rect = (Rect)characteristics.Get(CameraCharacteristics.SensorInfoActiveArraySize);
int minW = (int)(rect.Width() / maxzoom);
int minH = (int)(rect.Height() / maxzoom);
int difW = rect.Width() - minW;
int difH = rect.Height() - minH;
int cropW = difW / 100 * (int)zoomLevel;
int cropH = difH / 100 * (int)zoomLevel;
cropW -= cropW & 3;
cropH -= cropH & 3;
Rect zoom = new Rect(cropW, cropH, rect.Width() - cropW, rect.Height() - cropH);
mPreviewRequestBuilder.Set(CaptureRequest.ScalerCropRegion, zoom);
try
{
mCaptureSession.SetRepeatingRequest(mPreviewRequestBuilder.Build(), mCaptureCallback, null);
}
catch (CameraAccessException ex)
{
ex.PrintStackTrace();
}
catch (NullPointerException ex)
{
ex.PrintStackTrace();
}
}
private void SetUpCameraOutputs(int width, int height)
{
_manager = (CameraManager)_context.GetSystemService(Context.CameraService);
string[] cameraIds = _manager.GetCameraIdList();
_cameraId = cameraIds[0];
for (int i = 0; i < cameraIds.Length; i++)
{
CameraCharacteristics chararc = _manager.GetCameraCharacteristics(cameraIds[i]);
sensorOrientation = (int)chararc.Get(CameraCharacteristics.SensorOrientation);
var facing = (Integer)chararc.Get(CameraCharacteristics.LensFacing);
if (facing != null && facing == (Integer.ValueOf((int)LensFacing.Back)))
{
_cameraId = cameraIds[i];
//Phones like Galaxy S10 have 2 or 3 frontal cameras usually the one with flash is the one
//that should be chosen, if not It will select the first one and that can be the fish
//eye camera
if (HasFLash(chararc))
{
break;
}
}
}
var characteristics = _manager.GetCameraCharacteristics(_cameraId);
var map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
if (_supportedJpegSizes == null && characteristics != null)
{
_supportedJpegSizes = ((StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap)).GetOutputSizes((int)ImageFormatType.Jpeg);
}
if (_supportedJpegSizes != null && _supportedJpegSizes.Length > 0)
{
_idealPhotoSize = GetOptimalSize(_supportedJpegSizes, 1050, 1400); //MAGIC NUMBER WHICH HAS PROVEN TO BE THE BEST
}
_imageReader = ImageReader.NewInstance(_idealPhotoSize.Width, _idealPhotoSize.Height, ImageFormatType.Jpeg, 1);
var windowManager = _context.GetSystemService(Context.WindowService).JavaCast <IWindowManager>();
int rotation = (int)windowManager.DefaultDisplay.Rotation;
int orientation = GetOrientation(rotation);
var readerListener = new ImageAvailableListener(orientation);
readerListener.Photo += (sender, buffer) =>
{
Photo?.Invoke(this, buffer);
};
_flashSupported = HasFLash(characteristics);
_imageReader.SetOnImageAvailableListener(readerListener, _backgroundHandler);
_previewSize = GetOptimalSize(map.GetOutputSizes(Class.FromType(typeof(SurfaceTexture))), width, height);
}
public void OpenCamera(bool IsSwitchCam)
{
cameraManager = (CameraManager)GetSystemService(Context.CameraService);
try
{
SyncCameraPosition(IsSwitchCam);
string cameraId = cameraManager.GetCameraIdList()[CurrentCameraIndex];
CameraCharacteristics characteristics = cameraManager.GetCameraCharacteristics(cameraId);
StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
previewSize = map.GetOutputSizes(Java.Lang.Class.FromType(typeof(SurfaceTexture)))[0];
Android.Content.Res.Orientation orientation = Resources.Configuration.Orientation;
if (orientation == Android.Content.Res.Orientation.Landscape)
{
autoFitTextureView.SetAspectRatio(previewSize.Width, previewSize.Height);
}
else
{
autoFitTextureView.SetAspectRatio(previewSize.Height, previewSize.Width);
}
HandlerThread thread = new HandlerThread("CameraPreview");
thread.Start();
Handler backgroundHandler = new Handler(thread.Looper);
cameraManager.OpenCamera(cameraId, cameraStateListener, null);
var available = (bool)characteristics.Get(CameraCharacteristics.FlashInfoAvailable);
if (available)
{
FlashSupported = true;
}
else
{
FlashSupported = false;
}
}
catch (Java.Lang.Exception error)
{
ShowToastMessage("Failed to open camera");
DebugMessage("ErrorMessage: \n" + error.Message + "\n" + "Stacktrace: \n " + error.StackTrace);
}
catch (System.Exception error)
{
ShowToastMessage("Failed to open camera");
DebugMessage("ErrorMessage: \n" + error.Message + "\n" + "Stacktrace: \n " + error.StackTrace);
}
}
private bool IsSwappedDimensions(CameraCharacteristics characteristics)
{
var displayRotation = Utils.CalculateRotation();
//noinspection ConstantConditions
var mSensorOrientation = _rotation = (int)characteristics.Get(CameraCharacteristics.SensorOrientation);
var swappedDimensions = false;
switch (displayRotation)
{
case SurfaceOrientation.Rotation0:
case SurfaceOrientation.Rotation180:
if (mSensorOrientation == 90 || mSensorOrientation == 270)
{
swappedDimensions = true;
}
break;
case SurfaceOrientation.Rotation90:
case SurfaceOrientation.Rotation270:
if (mSensorOrientation == 0 || mSensorOrientation == 180)
{
swappedDimensions = true;
}
break;
default:
Debug.WriteLine("Display rotation is invalid: " + displayRotation);
break;
}
return(swappedDimensions);
}
/// <summary>
/// Opens the camera.
/// </summary>
public void OpenCamera()
{
if (_context == null || OpeningCamera)
{
return;
}
OpeningCamera = true;
_manager = (CameraManager)_context.GetSystemService(Context.CameraService);
try
{
string cameraId = _manager.GetCameraIdList()[0];
// To get a list of available sizes of camera preview, we retrieve an instance of
// StreamConfigurationMap from CameraCharacteristics
CameraCharacteristics characteristics = _manager.GetCameraCharacteristics(cameraId);
StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
_previewSize = map.GetOutputSizes(Java.Lang.Class.FromType(typeof(SurfaceTexture)))[0];
Android.Content.Res.Orientation orientation = Resources.Configuration.Orientation;
if (orientation == Android.Content.Res.Orientation.Landscape)
{
_cameraTexture.SetAspectRatio(_previewSize.Width, _previewSize.Height);
}
else
{
_cameraTexture.SetAspectRatio(_previewSize.Height, _previewSize.Width);
}
HandlerThread thread = new HandlerThread("CameraPreview");
thread.Start();
Handler backgroundHandler = new Handler(thread.Looper);
// We are opening the camera with a listener. When it is ready, OnOpened of mStateListener is called.
_manager.OpenCamera(cameraId, _stateListener, null);
}
catch (Java.Lang.Exception error)
{
_log.WriteLineTime(_tag + "\n" +
"OpenCamera() Failed to open camera \n " +
"ErrorMessage: \n" +
error.Message + "\n" +
"Stacktrace: \n " +
error.StackTrace);
Available?.Invoke(this, false);
}
catch (System.Exception error)
{
_log.WriteLineTime(_tag + "\n" +
"OpenCamera() Failed to open camera \n " +
"ErrorMessage: \n" +
error.Message + "\n" +
"Stacktrace: \n " +
error.StackTrace);
Available?.Invoke(this, false);
}
}
/// <summary>
/// 初始化摄像头
/// </summary>
private void InitCamera()
{
try
{
CameraManager = (CameraManager)Context.GetSystemService(Context.CameraService);
var cameraId = ((int)choseCameraFacing).ToString();
this.CameraCharacteristics = CameraManager.GetCameraCharacteristics(cameraId);
var jk = new Java.Lang.Integer((int)CameraCharacteristics.Get(CameraCharacteristics.InfoSupportedHardwareLevel));
var map = (StreamConfigurationMap)CameraCharacteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
previewSize = map.GetOutputSizes(Java.Lang.Class.FromType(typeof(SurfaceTexture)))[0];
CameraManager.OpenCamera(cameraId, GetCameraStateCallBack(), null);
}
catch (Exception ex)
{
}
}
private void OpenCamera()
{
var cameraManager = GetCameraManager();
string cameraId = cameraManager.GetCameraIdList()[0];
CameraCharacteristics cameraCharacteristics
= cameraManager.GetCameraCharacteristics(cameraId);
var configurationMap = (StreamConfigurationMap)cameraCharacteristics.Get
(
CameraCharacteristics.ScalerStreamConfigurationMap
);
_imageDimension = configurationMap.GetOutputSizes(Class.FromType(typeof(SurfaceTexture)))[0];
// Add permission for camera and let user grant the permission
/*if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
* ActivityCompat.requestPermissions(AndroidCameraApi.this, new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE
* }, REQUEST_CAMERA_PERMISSION);
* return;
* }*/
cameraManager.OpenCamera(cameraId,
new CameraDeviceStateCallback(CreateCameraDevice,
CreateCameraPreview),
null);
}
void GetCameraIds()
{
try
{
CameraManager manager = (CameraManager)Context.GetSystemService(Context.CameraService);
string[] cameraIds = manager.GetCameraIdList();
foreach (string id in cameraIds)
{
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(id);
LensFacing lensFacing = (LensFacing)(int)characteristics.Get(CameraCharacteristics.LensFacing);
if (lensFacing == LensFacing.Back)
{
BackCameraAvailable = true;
backCameraId = id;
}
else if (lensFacing == LensFacing.Front)
{
FrontCameraAvailable = true;
frontCameraId = id;
}
}
}
catch (CameraAccessException)
{
Toast.MakeText(Context, "Cannot access the camera.", ToastLength.Short).Show();
}
catch (NullPointerException)
{
Toast.MakeText(Context, "This device doesn't support Camera2 API.", ToastLength.Short).Show();
}
}
//Tries to open a CameraDevice
public void openCamera()
{
if (null == Activity || Activity.IsFinishing || opening_camera)
{
return;
}
opening_camera = true;
CameraManager manager = (CameraManager)Activity.GetSystemService(Context.CameraService);
try {
string camera_id = manager.GetCameraIdList()[0];
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(camera_id);
StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
preview_size = map.GetOutputSizes(Java.Lang.Class.FromType(typeof(SurfaceTexture)))[0];
int orientation = (int)Resources.Configuration.Orientation;
if (orientation == (int)Android.Content.Res.Orientation.Landscape)
{
texture_view.SetAspectRatio(preview_size.Width, preview_size.Height);
}
else
{
texture_view.SetAspectRatio(preview_size.Height, preview_size.Width);
}
manager.OpenCamera(camera_id, state_listener, null);
} catch (CameraAccessException) {
Toast.MakeText(Activity, "Cannot access the camera.", ToastLength.Short).Show();
Activity.Finish();
} catch (NullPointerException) {
var dialog = new ErrorDialog();
dialog.Show(FragmentManager, "dialog");
}
}
public void SurfaceCreated(ISurfaceHolder holder)
{
try
{
if (!(Context.GetSystemService(Class.FromType(typeof(CameraManager))) is CameraManager manager))
{
return;
}
string frontCameraId = manager.GetCameraIdList().FirstOrDefault(id => IsFrontFacingCamera(manager, id));
CameraCharacteristics frontCamera = manager.GetCameraCharacteristics(frontCameraId);
if (!(frontCamera?.Get(CameraCharacteristics.ScalerStreamConfigurationMap) is StreamConfigurationMap map))
{
return;
}
Size[] outputSizes = map.GetOutputSizes(Class.FromType(holder.GetType()));
Size firstSmall = outputSizes
.Where(size => (double)size.Width / size.Height == 16d / 9)
.First(size => size.Height < 900 && size.Width < 900);
holder.SetFixedSize(firstSmall.Width, firstSmall.Height);
CameraDevice.StateCallback stateCallback = new MyCameraCallback(holder.Surface, Element);
manager.OpenCamera(frontCameraId, stateCallback, new Handler(msg => { }));
}
catch (Java.IO.IOException ex)
{
Console.WriteLine(ex.Message);
}
}
public static List <string> GetCameras()
{
var ctx = Application.Context;
var manager = (CameraManager)ctx.GetSystemService(Context.CameraService);
var result = new List <string>();
try
{
for (var i = 0; i < manager.GetCameraIdList().Length; i++)
{
var cameraId = manager.GetCameraIdList()[i];
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(cameraId);
// We don't use a front facing camera in this sample.
var facing = (Java.Lang.Integer)characteristics.Get(CameraCharacteristics.LensFacing);
if (facing != null && facing == (Java.Lang.Integer.ValueOf((int)LensFacing.Front)))
{
continue;
}
result.Add(cameraId);
}
}
catch (System.Exception)
{
//TODO: error handling
}
return(result);
}
public static string GetCam(CameraManager _manager, Video.CAMERA_POSITION pos)
{
string desiredCameraId = null;
foreach (string cameraId in _manager.GetCameraIdList())
{
CameraCharacteristics chars = _manager.GetCameraCharacteristics(cameraId);
//List < CameraCharacteristics.Key <?>> keys = chars.getKeys();
try
{
if ((int)chars.Get(CameraCharacteristics.LensFacing) == ((pos == Video.CAMERA_POSITION.REAR)?(int)LensFacing.Back:(int)LensFacing.Front))
{
// This is the one we want.
desiredCameraId = cameraId;
return(desiredCameraId);
}
}
catch (IllegalArgumentException)
{
// This key not implemented, which is a bit of a pain. Either guess - assume the first one
// is rear, second one is front, or give up.
}
}
return(_manager.GetCameraIdList()[0]);
}
private void OpenCamera()
{
CameraManager manager = (CameraManager)GetSystemService(CameraService);
var facing = -1;
foreach (var id in manager.GetCameraIdList())
{
CameraCharacteristics cam_opt = manager.GetCameraCharacteristics(id);
facing = (int)(cam_opt.Get(CameraCharacteristics.LensFacing) ?? -1);
if (facing > -1 && facing == (int)CameraFacing)
{
break;
}
}
if (facing > -1)
{
Intent intent = new Intent(MediaStore.ActionImageCapture);
intent.PutExtra("android.intent.extras.CAMERA_FACING", facing);
CreateSnackBar("Opening the " + (facing == 0 ? "Front" : "Back") + " Camera");
StartActivityForResult(intent, 0);
}
else
{
CreateSnackBar("No Camera devices found.");
}
}
private void SetUpCameraOutputs(int width, int height)
{
manager = (CameraManager)context.GetSystemService(Context.CameraService);
string[] cameraIds = manager.GetCameraIdList();
cameraId = cameraIds[0];
for (int i = 0; i < cameraIds.Length; i++)
{
CameraCharacteristics chararc = manager.GetCameraCharacteristics(cameraIds[i]);
var facing = (Integer)chararc.Get(CameraCharacteristics.LensFacing);
if (facing != null && facing == (Integer.ValueOf((int)lensFacing)))
{
continue;
}
cameraId = cameraIds[i];
}
var characteristics = manager.GetCameraCharacteristics(cameraId);
var map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
if (supportedJpegSizes == null && characteristics != null)
{
supportedJpegSizes = ((StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap)).GetOutputSizes((int)ImageFormatType.Jpeg);
}
if (supportedJpegSizes != null && supportedJpegSizes.Length > 0)
{
//MAGIC NUMBER WHICH HAS PROVEN TO BE THE BEST
idealPhotoSize = GetOptimalSize(supportedJpegSizes, 950, 1200);
}
imageReader = ImageReader.NewInstance(idealPhotoSize.Width, idealPhotoSize.Height, ImageFormatType.Jpeg, 1);
ImageAvailableListener readerListener = new ImageAvailableListener();
readerListener.Photo += (sender, buffer) =>
{
Photo?.Invoke(this, buffer);
};
var available = (Java.Lang.Boolean)characteristics.Get(CameraCharacteristics.FlashInfoAvailable);
if (available == null)
{
flashSupported = false;
}
else
{
flashSupported = (bool)available;
}
imageReader.SetOnImageAvailableListener(readerListener, backgroundHandler);
previewSize = GetOptimalSize(map.GetOutputSizes(Class.FromType(typeof(SurfaceTexture))), width, height);
}
public void AdjustZoom(int value)
{
try
{
Activity activity = Activity;
CameraManager manager = (CameraManager)activity.GetSystemService(Context.CameraService);
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(mCameraId);
float maxzoom = ((float)characteristics.Get(CameraCharacteristics.ScalerAvailableMaxDigitalZoom)) * 10;
Rect m = (Rect)characteristics.Get(CameraCharacteristics.SensorInfoActiveArraySize);
// Multi touch logic
double scaling = (double)(maxzoom) / (double)200;
zoom_level = Convert.ToInt32(value * scaling);
if (zoom_level == 0)
{
zoom_level = 1;
}
int minW = (int)(m.Width() / maxzoom);
int minH = (int)(m.Height() / maxzoom);
int difW = m.Width() - minW;
int difH = m.Height() - minH;
int cropW = difW / 100 * (int)zoom_level;
int cropH = difH / 100 * (int)zoom_level;
cropW -= cropW & 3;
cropH -= cropH & 3;
Rect zoom = new Rect(cropW, cropH, m.Width() - cropW, m.Height() - cropH);
mPreviewRequestBuilder.Set(CaptureRequest.ScalerCropRegion, zoom);
mCaptureSession?.SetRepeatingRequest(mPreviewRequest = mPreviewRequestBuilder.Build(), null, mBackgroundHandler);
}
catch (System.Exception)
{
}
}
/*
* Helpful debugging method: Dump all supported camera formats to log. You don't need to run
* this for normal operation, but it's very helpful when porting this code to different
* hardware.
*/
public static void DumpFormatInfo(Context context)
{
// Discover the camera instance
CameraManager manager = (CameraManager)context.GetSystemService(Context.CameraService);
string[] camIds = null;
try
{
camIds = manager.GetCameraIdList();
}
catch (CameraAccessException e)
{
Log.Warn(TAG, "Cannot get the list of available cameras", e);
}
if (camIds == null || camIds.Length < 1)
{
Log.Debug(TAG, "No cameras found");
return;
}
Log.Debug(TAG, "Using camera id " + camIds[0]);
try
{
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(camIds[0]);
StreamConfigurationMap configs = (StreamConfigurationMap)characteristics.Get(
CameraCharacteristics.ScalerStreamConfigurationMap);
foreach (var format in configs.GetOutputFormats())
{
Log.Debug(TAG, "Getting sizes for format: " + format);
foreach (var s in configs.GetOutputSizes(format))
{
Log.Debug(TAG, "\t" + s.ToString());
}
}
int[] effects = (int[])characteristics.Get(CameraCharacteristics.ControlAvailableEffects);
foreach (var effect in effects)
{
Log.Debug(TAG, "Effect available: " + effect);
}
}
catch (CameraAccessException)
{
Log.Debug(TAG, "Cam access exception getting characteristics.");
}
}
void GetFrontSizes()
{
CameraManager manager = (CameraManager)Context.GetSystemService(Context.CameraService);
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(frontCameraId);
StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
frontCameraSizes = map.GetOutputSizes(Class.FromType(typeof(SurfaceTexture)));
}
/// <summary>
/// Gets the rear camera if possible, if not, then uses the front camera.
/// </summary>
/// <returns></returns>
private string GetCameraIdForOrientation(LensFacing facingToMatch)
{
CameraCharacteristics characteristics = null;
return(cameraManager.GetCameraIdList().FirstOrDefault(id => {
characteristics = cameraManager.GetCameraCharacteristics(id);
int lensFacing = (int)characteristics.Get(CameraCharacteristics.LensFacing);
return lensFacing == (int)facingToMatch;
}));
}
/// <summary>
/// Finds the rear camera, and begins a session with it. Transforms the live view so that it
/// is the correct orientation for the sensor/screen, and scales it to fit within its container.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void StartCamera(object sender = null, EventArgs args = null)
{
string cameraId =
GetCameraIdForOrientation(LensFacing.Back) ??
GetCameraIdForOrientation(LensFacing.Front) ??
GetCameraIdForOrientation(LensFacing.External);
if (cameraId == null)
{
(Element as LabelReader)?.CameraError(LabelReaderConstants.NoCameraMessage);
return;
}
CameraCharacteristics characteristics = cameraManager.GetCameraCharacteristics(cameraId);
sensorOrientation = (int)characteristics.Get(CameraCharacteristics.SensorOrientation);
SetupPreviewMatrix();
int bestWidth = 0;
var map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
global::Android.Util.Size[] outputSizes = map.GetOutputSizes((int)ImageFormatType.Jpeg);
IEnumerable <global::Android.Util.Size> bigSizes = outputSizes.Where(size => size.Width >= LabelReaderConstants.MinimumUsefulImageWidthPixels);
if (!bigSizes.Any())
{
bestWidth = outputSizes.Max(size => size.Width);
}
else
{
bestWidth = bigSizes.Min(size => size.Width);
}
global::Android.Util.Size bestSize = outputSizes.First(size => size.Width == bestWidth);
Reader = ImageReader.NewInstance(bestSize.Width, bestSize.Height, ImageFormatType.Jpeg, 2);
Reader.SetOnImageAvailableListener(CameraImageReaderListener, null);
cameraManager.OpenCamera(cameraId, StateCallback, null);
}
public void StartCamera()
{
//アプリ起動時に,表示領域が未作成の前にStartCameraが実行されることを防ぐ
if (this.SurfaceTexture == null)
{
return;
}
StartBackgroundThread();
this._cameraManager = (CameraManager)Android.App.Application.Context.GetSystemService(Context.CameraService);
var cameraIdList = this._cameraManager.GetCameraIdList();
CameraCharacteristics cameraCharacteristics = null;
//指定のカメラのidを取得する
//フロント,バックのカメラidの取得についてはこちらを参考
//https://bellsoft.jp/blog/system/detail_538
this._cameraId = cameraIdList.FirstOrDefault(cId =>
{
cameraCharacteristics = _cameraManager.GetCameraCharacteristics(cId);
var lensFacing = (int)cameraCharacteristics.Get(CameraCharacteristics.LensFacing);
if (lensFacing == (int)this.CameraOption)
{
return(true);
}
return(false);
});
Android.Hardware.Camera2.Params.StreamConfigurationMap scm = (Android.Hardware.Camera2.Params.StreamConfigurationMap)cameraCharacteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
this.PreviewSize = scm.GetOutputSizes((int)ImageFormatType.Jpeg)[0];
this.SensorOrientation = (int)cameraCharacteristics.Get(CameraCharacteristics.SensorOrientation);//Back:4032*3024,Front:3264*2448
//ImageReaderの設定
this.ImageReader = ImageReader.NewInstance(480, 640, ImageFormatType.Jpeg, 1);
this.ImageReader.SetOnImageAvailableListener(this.ImageAvailableListener, this.BackgroundHandler);
this._cameraStateListener = new CameraStateListener(this);
_cameraManager.OpenCamera(_cameraId, this._cameraStateListener, null);
}
private void SetLensFacing(LensFacing lenseFacing)
{
bool shouldRestartCamera = currentLensFacing != lenseFacing;
currentLensFacing = lenseFacing;
string cameraId = string.Empty;
characteristics = null;
foreach (var id in manager.GetCameraIdList())
{
cameraId = id;
characteristics = manager.GetCameraCharacteristics(id);
var face = (int)characteristics.Get(CameraCharacteristics.LensFacing);
if (face == (int)currentLensFacing)
{
break;
}
}
if (characteristics == null)
{
return;
}
if (cameraDevice != null)
{
try
{
if (!shouldRestartCamera)
{
return;
}
if (cameraDevice.Handle != IntPtr.Zero)
{
cameraDevice.Close();
cameraDevice.Dispose();
cameraDevice = null;
}
}
catch (Exception e)
{
//Ignored
System.Diagnostics.Debug.WriteLine(e);
}
}
SetUpCameraOutputs(cameraId);
ConfigureTransform(surfaceTextureView.Width, surfaceTextureView.Height);
manager.OpenCamera(cameraId, cameraStateCallback, null);
}
private bool HasFLash(CameraCharacteristics characteristics)
{
var available = (Java.Lang.Boolean)characteristics.Get(CameraCharacteristics.FlashInfoAvailable);
if (available == null)
{
return(false);
}
else
{
return((bool)available);
}
}
protected override void FindLargestResolution()
{
StreamConfigurationMap map =
(StreamConfigurationMap)CameraCharacteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
DroidSize[] imageSupportedSizesAndroid = map.GetOutputSizes((int)ImageFormatType.Jpeg);
DroidSize largestSizeAndroid = imageSupportedSizesAndroid
.OrderByDescending(droidSize => (long)droidSize.Height * droidSize.Width)
.FirstOrDefault();
_largestImageResolution = new Size(largestSizeAndroid.Width, largestSizeAndroid.Height);
}
public void configureStream()
{
CameraCharacteristics characteristics = _cameraManager.GetCameraCharacteristics(_id);
StreamConfigurationMap configs = (StreamConfigurationMap)(characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap));
sa = configs.GetOutputSizes(Java.Lang.Class.FromType(typeof(SurfaceTexture)));
//sa = configs.GetOutputSizes((int)ImageFormatType.Nv16);
for (int i = 0; i < sa.Length; i++)
{
System.Diagnostics.Debug.WriteLine("width : " + sa[i].Width + " Height : " + sa[i].Height + "\n");
}
}
/// <summary>
/// Finds the camera properties.
/// </summary>
/// <param name="defaultCamera">The default camera.</param>
/// <exception cref="ArgumentOutOfRangeException">defaultCamera</exception>
private void FindCameraProperties(CameraChoice defaultCamera)
{
switch (defaultCamera)
{
case CameraChoice.Rear:
Helper(LensFacing.Back);
break;
case CameraChoice.Front:
Helper(LensFacing.Front);
break;
default:
throw new ArgumentOutOfRangeException(nameof(defaultCamera), defaultCamera,
$"Only {CameraChoice.Front} & {CameraChoice.Rear} camera is supported.");
}
FindLargestResolution();
void Helper(LensFacing lensFacing)
{
foreach (string camId in Manager.GetCameraIdList())
{
CameraCharacteristics cameraCharacteristics = Manager.GetCameraCharacteristics(camId);
Integer facing = (Integer)cameraCharacteristics.Get(CameraCharacteristics.LensFacing);
if (facing != null && facing == Integer.ValueOf((int)lensFacing))
{
CameraCharacteristics = cameraCharacteristics;
CameraId = camId;
SensorOrientation = (int)CameraCharacteristics.Get(CameraCharacteristics.SensorOrientation);
// Check if flash is supported
Boolean flashAvailable = (Boolean)CameraCharacteristics.Get(CameraCharacteristics.FlashInfoAvailable);
FlashSupported = flashAvailable != null && (bool)flashAvailable;
}
}
}
}
public void ChangeFocusPoint(Xamarin.Forms.Point e)
{
string cameraId = _manager.GetCameraIdList()[0];
// To get a list of available sizes of camera preview, we retrieve an instance of
// StreamConfigurationMap from CameraCharacteristics
CameraCharacteristics characteristics = _manager.GetCameraCharacteristics(cameraId);
var rect = characteristics.Get(CameraCharacteristics.SensorInfoActiveArraySize) as Rect;
var size = characteristics.Get(CameraCharacteristics.SensorInfoPixelArraySize) as Size;
int areaSize = 200;
int right = rect.Right;
int bottom = rect.Bottom;
int viewWidth = _cameraTexture.Width;
int viewHeight = _cameraTexture.Height;
int ll, rr;
Rect newRect;
int centerX = (int)e.X;
int centerY = (int)e.Y;
ll = ((centerX * right) - areaSize) / viewWidth;
rr = ((centerY * bottom) - areaSize) / viewHeight;
int focusLeft = Clamp(ll, 0, right);
int focusBottom = Clamp(rr, 0, bottom);
newRect = new Rect(focusLeft, focusBottom, focusLeft + areaSize, focusBottom + areaSize);
MeteringRectangle meteringRectangle = new MeteringRectangle(newRect, 500);
MeteringRectangle[] meteringRectangleArr = { meteringRectangle };
_previewBuilder.Set(CaptureRequest.ControlAfTrigger, (int)ControlAFTrigger.Cancel);
_previewBuilder.Set(CaptureRequest.ControlAeRegions, meteringRectangleArr);
_previewBuilder.Set(CaptureRequest.ControlAfTrigger, (int)ControlAFTrigger.Start);
UpdatePreview();
}
public void OpenCamera()
{
var manager = (CameraManager)this.GetSystemService(Context.CameraService);
foreach (var cameraId in manager.GetCameraIdList())
{
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(cameraId);
if ((int)characteristics.Get(CameraCharacteristics.LensFacing) == (int)LensFacing.Back)
{
manager.OpenCamera(cameraId, stateCallBack, null);
return;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="width">Device screen width, in pixels.</param>
/// <param name="height">Device screen height, in pixels.</param>
public void SetupCamera(int width, int height)
{
CameraManager cameraManager = (CameraManager)mActivity.GetSystemService(Context.CameraService);
try
{
SurfaceTexture SurfaceTextureClassIntance = new SurfaceTexture(true);
foreach (string id in cameraManager.GetCameraIdList())
{
CameraCharacteristics characteristics = cameraManager.GetCameraCharacteristics(id);
int cameraLensFacing = (int)characteristics.Get(CameraCharacteristics.LensFacing);
if (cameraLensFacing == null)
{
continue;
}
if (cameraLensFacing != (int)LensFacing.Front)
{
continue;
}
StreamConfigurationMap maps =
(StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
if (maps == null || maps.GetOutputSizes(SurfaceTextureClassIntance.Class) == null)
{
continue;
}
mPreviewSize = getOptimalSize(maps.GetOutputSizes(SurfaceTextureClassIntance.Class), width, height);
mCameraId = id;
Log.Debug(TAG, "Preview width = " + mPreviewSize.Width + ", height = "
+ mPreviewSize.Height + ", cameraId = " + mCameraId);
break;
}
} catch (CameraAccessException e)
{
Log.Debug(TAG, "Set upCamera error");
}
}
//Tries to open a CameraDevice
public void OpenCamera(int width, int height)
{
if (null == Activity || Activity.IsFinishing)
{
return;
}
CameraManager manager = (CameraManager)Activity.GetSystemService(Context.CameraService);
try
{
if (!CameraOpenCloseLock.TryAcquire(2500, TimeUnit.Milliseconds))
{
throw new RuntimeException("Time out waiting to lock camera opening.");
}
string cameraId = manager.GetCameraIdList()[0];
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(cameraId);
StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
videoSize = ChooseVideoSize(map.GetOutputSizes(Class.FromType(typeof(MediaRecorder))));
previewSize = ChooseOptimalSize(map.GetOutputSizes(Class.FromType(typeof(MediaRecorder))), width, height, videoSize);
int orientation = (int)Resources.Configuration.Orientation;
if (orientation == (int)global::Android.Content.Res.Orientation.Landscape)
{
TextureView.SetAspectRatio(previewSize.Width, previewSize.Height);
}
else
{
TextureView.SetAspectRatio(previewSize.Height, previewSize.Width);
}
ConfigureTransform(width, height);
MediaRecorder = new MediaRecorder();
manager.OpenCamera(cameraId, stateListener, null);
}
catch (CameraAccessException)
{
Toast.MakeText(Activity, "Cannot access the camera.", ToastLength.Short).Show();
Activity.Finish();
}
catch (NullPointerException)
{
var dialog = new ErrorDialog();
dialog.Show(FragmentManager, "dialog");
}
catch (InterruptedException)
{
throw new RuntimeException("Interrupted while trying to lock camera opening.");
}
}