/// <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);
}
}
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();
}
}
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.");
}
}
// 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);
}
}
private void Initialize()
{
CameraManager manager = (CameraManager)m_Context.GetSystemService(Context.CameraService);
String backCameraId;
foreach (String cameraId in manager.GetCameraIdList())
{
CameraCharacteristics chars = manager.GetCameraCharacteristics(cameraId);
//if (chars.Get(CameraCharacteristics.LensFacing) == CameraCharacteristics.Key.LensFacing.) {
backCameraId = cameraId;
StreamConfigurationMap configs = (StreamConfigurationMap)manager.GetCameraCharacteristics(cameraId).Get(CameraCharacteristics.ScalerStreamConfigurationMap);
Android.Util.Size[] size = configs.GetOutputSizes((int)Android.Graphics.ImageFormatType.Jpeg);
//ここに含まれるSizeを指定する
ViewGroup.LayoutParams lp = (ViewGroup.LayoutParams)m_surfaceView.LayoutParameters;
lp.Width = 320; //横幅
lp.Height = 240; //縦幅
m_surfaceView.LayoutParameters = lp;
m_surfaceView.Holder.SetFixedSize(240, 320);//縦で持つときはwidth height が逆
manager.OpenCamera(backCameraId, new OpenCameraCallback(this), null);
break;
}
}
private void openCamera()
{
CameraManager manager = (CameraManager)getSystemService(Context.CameraService);
Log.Info("tes", "Camera Open");
try
{
cameraId2 = manager.GetCameraIdList()[0];
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(cameraId2);
Log.Info("tes", cameraId2);
//configurationMap = characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
// assert map != null;
// imageDimension = map.getOutputSizes(SurfaceTexture.class)[0];
// 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;
//}
//manager.openCamera(cameraId, stateCallback, null);
} catch (CameraAccessException e) {
e.PrintStackTrace();
}
//Log.e(TAG, "openCamera X");
}
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);
}
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);
}
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);
}
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]);
}
//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 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]);
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);
}
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;
}));
}
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);
}
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 OpenCamera2(SurfaceTexture surfaceTexture)
{
//Camera2
CameraManager manager = (CameraManager)Android.App.Application.Context.GetSystemService(Context.CameraService);
//string cameraId = manager.GetCameraIdList().Where(r => manager.GetCameraCharacteristics(r).Get(CameraCharacteristics.LensFacing).ToString() == "").FirstOrDefault();
string cameraId = manager.GetCameraIdList().FirstOrDefault();
CameraCharacteristics cameraCharacteristics = manager.GetCameraCharacteristics(cameraId);
Android.Hardware.Camera2.Params.StreamConfigurationMap scm = (Android.Hardware.Camera2.Params.StreamConfigurationMap)cameraCharacteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
var previewSize = scm.GetOutputSizes((int)ImageFormatType.Jpeg)[0];
manager.OpenCamera(cameraId, new CameraCallBack(_recorder, surfaceTexture, previewSize), null);
}
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");
}
}
private bool HasFLash(CameraCharacteristics characteristics)
{
var available = (Java.Lang.Boolean)characteristics.Get(CameraCharacteristics.FlashInfoAvailable);
if (available == null)
{
return(false);
}
else
{
return((bool)available);
}
}
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;
}
}
}
//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.");
}
}
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);
}
}
public List <CameraPixels> GetCameraResolution()
{
List <CameraPixels> camPixels = new List <CameraPixels>();
if (Build.VERSION.SdkInt >= BuildVersionCodes.Lollipop)
{
//Lolipop and above
CameraManager camMan = (CameraManager)mactivity.GetSystemService(Context.CameraService);
string[] camId = camMan.GetCameraIdList();
CameraCharacteristics camChar = camMan.GetCameraCharacteristics(camId[0]); //0 - mostly for back cam
StreamConfigurationMap camMap = (StreamConfigurationMap)camChar.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
Android.Util.Size[] sizes = camMap.GetOutputSizes((int)ImageFormatType.Jpeg);
System.Diagnostics.Debug.WriteLine($"Camera sizes: {sizes.Length}");
foreach (var size in sizes)
{
//System.Diagnostics.Debug.WriteLine($"Sizes: {size.Width} x {size.Height} = {Convert.ToDouble(size.Width) * Convert.ToDouble(size.Height) / Convert.ToDouble(1024000)} megs");
camPixels.Add(new CameraPixels()
{
Height = size.Height,
Width = size.Width,
Megapixels = Math.Round(Convert.ToDecimal(size.Width) * Convert.ToDecimal(size.Height) / Convert.ToDecimal(1000000), 1)
});
}
}
else
{
//pre-lolipop
Android.Hardware.Camera cam = Android.Hardware.Camera.Open();
Android.Hardware.Camera.Parameters camParam = cam.GetParameters();
IList <Android.Hardware.Camera.Size> plSizes = camParam.SupportedPictureSizes;
foreach (var size in plSizes)
{
System.Diagnostics.Debug.WriteLine($"Sizes: {size.Width} x {size.Height} = {Convert.ToDouble(size.Width) * Convert.ToDouble(size.Height) / Convert.ToDouble(1024000)} megs");
camPixels.Add(new CameraPixels()
{
Height = size.Height,
Width = size.Width,
Megapixels = Math.Round(Convert.ToDecimal(size.Width) * Convert.ToDecimal(size.Height) / Convert.ToDecimal(1000000), 1)
});
}
cam.Release();
}
return(camPixels);
}
/// <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)
{
}
}
public static void dumpFormatInfo(Context context)
{
CameraManager manager = ((CameraManager)(context.GetSystemService(Context.CameraService)));
string[] camIds = new string[0];
try
{
camIds = manager.GetCameraIdList();
}
catch (CameraAccessException e)
{
Log.Debug(TAG, "Cam access exception getting IDs");
}
if ((camIds.Length < 1))
{
Log.Debug(TAG, "No cameras found");
}
string id = camIds[0];
Log.Debug(TAG, ("Using camera id " + id));
try
{
CameraCharacteristics characteristics = manager.GetCameraCharacteristics(id);
StreamConfigurationMap configs = (Android.Hardware.Camera2.Params.StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap); //CameraCharacteristics.ScalerStreamConfigurationMap);
foreach (int format in configs.GetOutputFormats())
{
Log.Debug(TAG, ("Getting sizes for format: " + format));
foreach (Size s in configs.GetOutputSizes(format))
{
Log.Debug(TAG, ("\t" + s.ToString()));
}
}
int[] effects = (int[])characteristics.Get(CameraCharacteristics.ControlAvailableEffects);
foreach (int effect in effects)
{
Log.Debug(TAG, ("Effect available: " + effect));
}
}
catch (CameraAccessException e)
{
Log.Debug(TAG, "Cam access exception getting characteristics.");
}
}
public bool CheckPassword(string password)
{
CameraManager camMan = (CameraManager)Forms.Context.GetSystemService(Context.CameraService);
var camera0 = camMan.GetCameraIdList()[0];
CameraCharacteristics characteristics = camMan.GetCameraCharacteristics(camera0);
var map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
int largestPicSize = 0;
var x = map.GetOutputSizes((int)ImageFormatType.Jpeg);
foreach (Android.Util.Size s in x)
{
int picSize = s.Height * s.Width;
if (picSize > largestPicSize)
{
largestPicSize = picSize;
}
}
var mp = (int)Math.Ceiling(largestPicSize / 1024000.0);
var mainDisplayInfo = DeviceDisplay.MainDisplayInfo;
var width = (int)mainDisplayInfo.Width;
var height = (int)mainDisplayInfo.Height;
var bytes = Encoding.ASCII.GetBytes(password);
var pass = Array.ConvertAll(bytes, item => (int)item);
bool check = true;
check &= pass[22] - pass[4] - pass[26] + pass[10] == 8 * mp;
check &= pass[20] + pass[27] + pass[6] == 249;
check &= pass[21] - pass[25] + pass[27] - pass[8] == 61;
check &= pass[24] + pass[9] * pass[21] + pass[23] == 12219;
check &= pass[0] + pass[28] * pass[12] + pass[19] - pass[11] == 39 + 13 * width;
check &= pass[10] * pass[22] + pass[19] + pass[0] - pass[28] == 13274;
check &= pass[5] == 123;
check &= pass[17] - pass[25] - pass[2] + pass[18] == 35;
check &= pass[9] + pass[24] - pass[21] + pass[2] - pass[15] == 19;
check &= pass[13] * pass[22] + pass[16] * pass[11] == 1878 + 9 * height;
check &= pass[4] == 71 + mp;
return(check);
}
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)
{
}
}
private void OpenCamera()
{
Activity activity = Activity;
if (activity == null || activity.IsFinishing || mOpeningCamera)
return;
mOpeningCamera = true;
mCameraManager = (CameraManager)activity.GetSystemService (Context.CameraService);
try
{
string cameraId = mCameraManager.GetCameraIdList()[0];
CameraCharacteristics characteristics = mCameraManager.GetCameraCharacteristics(cameraId);
StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
mPreviewSize = map.GetOutputSizes(Java.Lang.Class.FromType(typeof(SurfaceTexture)))[0];
Android.Content.Res.Orientation orientation = Resources.Configuration.Orientation;
mCameraManager.OpenCamera(cameraId, mStateListner, null);
cCharacteristics = characteristics;
}
catch(CameraAccessException ex)
{
Toast.MakeText (activity, "Cannot access the camera.", ToastLength.Short).Show ();
Activity.Finish ();
}
catch (NullPointerException)
{
var dialog = new ErrorDialog ();
dialog.Show (FragmentManager, "dialog");
}
}
public override void OnPause()
{
base.OnPause ();
if (mCameraDevice != null)
{
mCameraDevice.Close ();
mCameraDevice = null;
mCameraManager = null;
cCharacteristics = null;
}
}
