void ChangeCamera(CameraViewController sender)
{
CameraButton.Enabled = false;
RecordButton.Enabled = false;
StillButton.Enabled = false;
SessionQueue.DispatchAsync(() => {
AVCaptureDevice currentVideoDevice = VideoDeviceInput.Device;
AVCaptureDevicePosition preferredPosition = AVCaptureDevicePosition.Unspecified;
AVCaptureDevicePosition currentPosition = currentVideoDevice.Position;
switch (currentPosition)
{
case AVCaptureDevicePosition.Unspecified:
case AVCaptureDevicePosition.Front:
preferredPosition = AVCaptureDevicePosition.Back;
break;
case AVCaptureDevicePosition.Back:
preferredPosition = AVCaptureDevicePosition.Front;
break;
}
AVCaptureDevice videoDevice = CreateDevice(AVMediaType.Video, preferredPosition);
AVCaptureDeviceInput videoDeviceInput = AVCaptureDeviceInput.FromDevice(videoDevice);
Session.BeginConfiguration();
// Remove the existing device input first, since using the front and back camera simultaneously is not supported.
Session.RemoveInput(VideoDeviceInput);
if (Session.CanAddInput(videoDeviceInput))
{
subjectSubscriber.Dispose();
SetFlashModeForDevice(AVCaptureFlashMode.Auto, videoDevice);
subjectSubscriber = NSNotificationCenter.DefaultCenter.AddObserver(AVCaptureDevice.SubjectAreaDidChangeNotification, SubjectAreaDidChange, videoDevice);
Session.AddInput(videoDeviceInput);
VideoDeviceInput = videoDeviceInput;
}
else
{
Session.AddInput(VideoDeviceInput);
}
AVCaptureConnection connection = MovieFileOutput.ConnectionFromMediaType(AVMediaType.Video);
if (connection.SupportsVideoStabilization)
{
connection.PreferredVideoStabilizationMode = AVCaptureVideoStabilizationMode.Auto;
}
Session.CommitConfiguration();
DispatchQueue.MainQueue.DispatchAsync(() => {
CameraButton.Enabled = true;
RecordButton.Enabled = true;
StillButton.Enabled = true;
});
});
}
AVCaptureDeviceInput pickCamera()
{
AVCaptureDevicePosition desiredPosition = AVCaptureDevicePosition.Back;
bool hadError = false;
foreach (var device in AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video))
{
if (device.Position == desiredPosition)
{
NSError error = null;
AVCaptureDeviceInput input = AVCaptureDeviceInput.FromDevice(device, out error);
if (error != null)
{
hadError = true;
displayErrorOnMainQueue(error, "Could not initialize for AVMediaTypeVideo");
}
else if (session.CanAddInput(input))
{
return(input);
}
}
}
if (!hadError)
{
displayErrorOnMainQueue(null, "No camera found for requested orientation");
}
return(null);
}
/// <summary>
/// 初期化処理
/// </summary>
private void Initialize()
{
previewLayer = new AVCaptureVideoPreviewLayer(CaptureSession)
{
Frame = Bounds,
VideoGravity = AVLayerVideoGravity.ResizeAspectFill,
};
AVCaptureDevice[] videoDevices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
AVCaptureDevicePosition cameraPosition = (cameraOptions == CameraOptions.Front) ? AVCaptureDevicePosition.Front : AVCaptureDevicePosition.Back;
device = videoDevices.FirstOrDefault(d => d.Position == cameraPosition);
//キャプチャデバイスの生成に失敗している場合エラー
if (device == null)
{
Console.WriteLine("CameraStartup Error");
return;
}
var input = new AVCaptureDeviceInput(device, out NSError error);
CaptureSession.AddInput(input);
// カメラの映像表示設定
Layer.AddSublayer(previewLayer);
// 映像出力設定後、少しだけ待機
Thread.Sleep(300);
// 出力開始
CaptureSession.StartRunning();
IsPreviewing = true;
// キャプチャー出力設定
PhotoOutput = new AVCapturePhotoOutput();
CaptureSession.AddOutput(PhotoOutput);
}
private AVCaptureDevice CameraWithPosition(AVCaptureDevicePosition position)
{
var defaultCamera = AVCaptureDevice.GetDefaultDevice(
AVCaptureDeviceType.BuiltInWideAngleCamera,
AVMediaType.Video, position);
return(defaultCamera);
}
private AVCaptureDevice CameraDeviceForPosition(AVCaptureDevicePosition position)
{
foreach (var device in AVCaptureDevice.Devices)
{
if (device.Position == position)
{
return(device);
}
}
return(null);
}
public AVCaptureDevice GetCameraForOrientation (AVCaptureDevicePosition orientation)
{
var devices = AVCaptureDevice.DevicesWithMediaType (AVMediaType.Video);
foreach (var device in devices) {
if (device.Position == orientation) {
return device;
}
}
return null;
}
/// <summary>
/// Videos the device available for passed in position.
/// </summary>
/// <returns>
/// The available device
/// </returns>
/// <param name='position'>
/// The desired Position.
/// </param>
static AVCaptureDevice VideoDeviceWithPosition(AVCaptureDevicePosition position)
{
var devices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
foreach (var device in devices)
{
if (device.Position == position)
{
return(device);
}
}
return(null);
}
private AVCaptureDevice CameraWithPosition(AVCaptureDevicePosition pos)
{
var devices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
foreach (var dev in devices)
{
if (dev.Position == pos)
{
return(dev);
}
}
return(null);
}
public AVCaptureDevice GetCameraForOrientation(AVCaptureDevicePosition orientation)
{
var devices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
foreach (var device in devices)
{
if (device.Position == orientation)
{
return(device);
}
}
return(null);
}
private AVCaptureDevice GetDeviceByPosition(AVCaptureDevicePosition position)
{
var captureDevices = RTCCameraVideoCapturer.CaptureDevices;
foreach (var device in captureDevices)
{
if (device.Position == position)
{
return(device);
}
}
return(captureDevices.FirstOrDefault());
}
static AVCaptureDevice CreateDevice(string mediaType, AVCaptureDevicePosition position)
{
AVCaptureDevice[] devices = AVCaptureDevice.DevicesWithMediaType(mediaType);
AVCaptureDevice captureDevice = devices [0];
foreach (var device in devices)
{
if (device.Position == position)
{
captureDevice = device;
break;
}
}
return(captureDevice);
}
public static AVCaptureDeviceDiscoverySession Create(AVCaptureDeviceType [] deviceTypes, string mediaType, AVCaptureDevicePosition position)
{
var arr = new NSMutableArray();
foreach (var device in deviceTypes)
{
arr.Add(device.GetConstant());
}
return(_Create(arr, mediaType, position));
}
public Task <OperationResult> ChanageCamera()
{
TaskCompletionSource <OperationResult> tcs = new TaskCompletionSource <OperationResult>();
AVCaptureDevice currentVideoDevice = _videoDeviceInput.Device;
AVCaptureDevicePosition preferredPosition = AVCaptureDevicePosition.Unspecified;
AVCaptureDevicePosition currentPosition = currentVideoDevice.Position;
switch (currentPosition)
{
case AVCaptureDevicePosition.Unspecified:
case AVCaptureDevicePosition.Front:
{
preferredPosition = AVCaptureDevicePosition.Back;
break;
}
case AVCaptureDevicePosition.Back:
{
preferredPosition = AVCaptureDevicePosition.Front;
break;
}
}
var result = AVCaptureDeviceFactory.CreateDevice(AVMediaType.Video, preferredPosition);
if (result.IsSuccessful)
{
AVCaptureDeviceInput videoDeviceInput = AVCaptureDeviceInput.FromDevice(result.Result);
if (_videoDeviceInput == null)
{
tcs.SetResult(OperationResult.AsFailure(@"Could not create video device input: {error}"));
return(tcs.Task);
}
_session.BeginConfiguration();
// Remove the existing device input first, since using the front and back camera simultaneously is not supported.
_session.RemoveInput(_videoDeviceInput);
if (_session.CanAddInput(videoDeviceInput))
{
if (_subjectSubscriber != null)
{
_subjectSubscriber.Dispose();
}
result.Result.SetFlashMode(AVCaptureFlashMode.Auto);
_subjectSubscriber = NSNotificationCenter.DefaultCenter.AddObserver(AVCaptureDevice.SubjectAreaDidChangeNotification, OnSubjectAreaChangedHandler, result.Result);
_session.AddInput(videoDeviceInput);
_videoDeviceInput = videoDeviceInput;
}
else
{
_session.AddInput(_videoDeviceInput);
}
AVCaptureConnection connection = _movieFileOutput.ConnectionFromMediaType(AVMediaType.Video);
if (connection.SupportsVideoStabilization)
{
connection.PreferredVideoStabilizationMode = AVCaptureVideoStabilizationMode.Auto;
}
_session.CommitConfiguration();
tcs.SetResult(OperationResult.AsSuccess());
}
else
{
tcs.SetResult(OperationResult.AsFailure("Failed to create video device: " + result.Message));
}
return(tcs.Task);
}
static AVCaptureDevice CreateDevice (string mediaType, AVCaptureDevicePosition position)
{
AVCaptureDevice[] devices = AVCaptureDevice.DevicesWithMediaType (mediaType);
AVCaptureDevice captureDevice = devices [0];
foreach (var device in devices) {
if (device.Position == position) {
captureDevice = device;
break;
}
}
return captureDevice;
}
void setupAVCapture()
{
NSError error = null;
AVCaptureSession session = new AVCaptureSession();
if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone)
{
session.SessionPreset = AVCaptureSession.Preset640x480;
}
else
{
session.SessionPreset = AVCaptureSession.PresetPhoto;
}
// Select a video device, make an input
AVCaptureDevice device = null;
AVCaptureDevicePosition desiredPosition = AVCaptureDevicePosition.Front;
// find the front facing camera
foreach (AVCaptureDevice d in AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video))
{
if (d.Position == desiredPosition)
{
device = d;
this.isUsingFrontFacingCamera = true;
break;
}
}
// fall back to the default camera.
if (device == null)
{
this.isUsingFrontFacingCamera = false;
device = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
}
// get the input device
AVCaptureDeviceInput deviceInput = AVCaptureDeviceInput.FromDevice(device, out error);
if (error == null)
{
// add the input to the session
if (session.CanAddInput(deviceInput))
{
session.AddInput(deviceInput);
}
// Make a video data output
this.videoDataOutput = new AVCaptureVideoDataOutput();
// we want BGRA, both CoreGraphics and OpenGL work well with 'BGRA'
NSDictionary rgbOutputSettings = new NSDictionary(
CVPixelBuffer.PixelFormatTypeKey,
CVPixelFormatType.CV32BGRA
);
this.videoDataOutput.WeakVideoSettings = rgbOutputSettings;
this.videoDataOutput.AlwaysDiscardsLateVideoFrames = true; // discard if the data output queue is blocked
// create a serial dispatch queue used for the sample buffer delegate
// a serial dispatch queue must be used to guarantee that video frames will be delivered in order
// see the header doc for setSampleBufferDelegate:queue: for more information
this.videoDataOutputQueue = new DispatchQueue("VideoDataOutputQueue");
this.videoDataOutput.SetSampleBufferDelegate(new CustomAVCaptureVideoDataOutputSampleBufferDelegate(this), this.videoDataOutputQueue);
if (session.CanAddOutput(this.videoDataOutput))
{
session.AddOutput(this.videoDataOutput);
}
// get the output for doing face detection.
this.videoDataOutput.ConnectionFromMediaType(AVMediaType.Video).Enabled = true;
this.previewLayer = new AVCaptureVideoPreviewLayer(session);
this.previewLayer.BackgroundColor = UIColor.Black.CGColor;
this.previewLayer.VideoGravity = AVLayerVideoGravity.ResizeAspect;
CALayer rootLayer = this.previewView.Layer;
rootLayer.MasksToBounds = true;
this.previewLayer.Frame = rootLayer.Bounds;
rootLayer.AddSublayer(this.previewLayer);
session.StartRunning();
}
session = null;
if (error != null)
{
UIAlertView alertView = new UIAlertView(
"Failed with error " + (int)error.Code,
error.LocalizedDescription,
null,
"Dismiss",
null);
alertView.Show();
this.teardownAVCapture();
}
}
static bool TryGetDefaultVideoCamera(AVCaptureDeviceType type, AVCaptureDevicePosition position, out AVCaptureDevice device)
{
device = AVCaptureDevice.GetDefaultDevice(type, AVMediaType.Video, position);
return(device != null);
}
public ARViewController() : base("ARViewController", null)
{
currentCaptureDevicePosition = AVCaptureDevicePosition.Unspecified;
}
public static OperationResult <AVCaptureDevice> CreateDevice(string mediaType, AVCaptureDevicePosition position)
{
AVCaptureDevice[] devices = AVCaptureDevice.DevicesWithMediaType(mediaType);
if (devices.Length > 0)
{
AVCaptureDevice captureDevice = devices[0];
foreach (var device in devices)
{
if (device.Position == position)
{
captureDevice = device;
break;
}
}
return(OperationResult <AVCaptureDevice> .AsSuccess(captureDevice));
}
else
{
return(OperationResult <AVCaptureDevice> .AsFailure("No devices found for provided media type"));
}
}
private AVCaptureDevice CameraDeviceForPosition(AVCaptureDevicePosition position)
{
foreach (var device in AVCaptureDevice.Devices)
if (device.Position == position)
return device;
return null;
}
public ArExperienceViewController(ArExperience arExperience) : base("ArExperienceViewController", null)
{
currentArExperience = arExperience;
currentCaptureDevicePosition = AVCaptureDevicePosition.Unspecified;
}
void ChangeCamera(UIButton cameraButton)
{
cameraButton.Enabled = false;
RecordButton.Enabled = false;
PhotoButton.Enabled = false;
LivePhotoModeButton.Enabled = false;
CaptureModeControl.Enabled = false;
sessionQueue.DispatchAsync(() => {
AVCaptureDevice currentVideoDevice = videoDeviceInput.Device;
AVCaptureDevicePosition currentPosition = currentVideoDevice.Position;
AVCaptureDevicePosition preferredPosition = 0;
AVCaptureDeviceType preferredDeviceType = 0;
switch (currentPosition)
{
case AVCaptureDevicePosition.Unspecified:
case AVCaptureDevicePosition.Front:
preferredPosition = AVCaptureDevicePosition.Back;
preferredDeviceType = AVCaptureDeviceType.BuiltInDuoCamera;
break;
case AVCaptureDevicePosition.Back:
preferredPosition = AVCaptureDevicePosition.Front;
preferredDeviceType = AVCaptureDeviceType.BuiltInWideAngleCamera;
break;
}
var devices = videoDeviceDiscoverySession.Devices;
AVCaptureDevice newVideoDevice = null;
// First, look for a device with both the preferred position and device type. Otherwise, look for a device with only the preferred position.
newVideoDevice = devices.FirstOrDefault(d => d.Position == preferredPosition && d.DeviceType == preferredDeviceType)
?? devices.FirstOrDefault(d => d.Position == preferredPosition);
if (newVideoDevice != null)
{
NSError error;
var input = AVCaptureDeviceInput.FromDevice(newVideoDevice, out error);
if (error == null)
{
session.BeginConfiguration();
// Remove the existing device input first, since using the front and back camera simultaneously is not supported.
session.RemoveInput(videoDeviceInput);
if (session.CanAddInput(input))
{
subjectSubscriber?.Dispose();
subjectSubscriber = NSNotificationCenter.DefaultCenter.AddObserver(AVCaptureDevice.SubjectAreaDidChangeNotification, SubjectAreaDidChange, input.Device);
session.AddInput(input);
videoDeviceInput = input;
}
else
{
session.AddInput(videoDeviceInput);
}
var connection = MovieFileOutput?.ConnectionFromMediaType(AVMediaType.Video);
if (connection != null)
{
if (connection.SupportsVideoStabilization)
{
connection.PreferredVideoStabilizationMode = AVCaptureVideoStabilizationMode.Auto;
}
}
// Set Live Photo capture enabled if it is supported.When changing cameras, the
// IsLivePhotoCaptureEnabled property of the AVCapturePhotoOutput gets set to false when
// a video device is disconnected from the session.After the new video device is
// added to the session, re - enable Live Photo capture on the AVCapturePhotoOutput if it is supported.
photoOutput.IsLivePhotoCaptureEnabled = photoOutput.IsLivePhotoCaptureSupported;
session.CommitConfiguration();
}
}
DispatchQueue.MainQueue.DispatchAsync(() => {
CameraButton.Enabled = true;
RecordButton.Enabled = MovieFileOutput != null;
PhotoButton.Enabled = true;
LivePhotoModeButton.Enabled = true;
CaptureModeControl.Enabled = true;
});
});
}
private void InitCamera()
{
//ADD DEVICE INPUTS
try
{
//If no camera avaiable, return
if (!IsCameraAvailable)
{
return;
}
//Set up a new AV capture session
session = new AVCaptureSession(); //Set up a new session
//add video capture device
var videoDevices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
AVCaptureDevicePosition cameraPosition = (CameraOption == CameraOptions.Front) ? AVCaptureDevicePosition.Front : AVCaptureDevicePosition.Back;
var device = videoDevices.FirstOrDefault(d => d.Position == cameraPosition); //Get the first device where the camera matches the requested camera
if (device == null)
{
//use the default camera if front isn't available
device = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
}
if (device == null)
{
return; //No device available
}
input = AVCaptureDeviceInput.FromDevice(device);
session.AddInput(input);
//add audio capture device
audioDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Audio);
audioInput = AVCaptureDeviceInput.FromDevice(audioDevice);
session.AddInput(audioInput);
}
catch (Exception ex)
{
return;
}
//Set up preview layer (shows what the input device sees)
previewlayer = new AVCaptureVideoPreviewLayer(session);
previewlayer.Frame = Bounds;
if (OrientationOption == OrientationOptions.Landscape)
{
//landscape
previewlayer.Connection.VideoOrientation = AVCaptureVideoOrientation.LandscapeRight; //Video is recoreded upside down but oriented correctly for right handed people
//previewlayer.Connection.VideoOrientation = AVCaptureVideoOrientation.Portrait; //VIdeo recorded portrait, face to left
//previewlayer.Connection.VideoOrientation = AVCaptureVideoOrientation.LandscapeLeft;
}
else
{
//portrait
previewlayer.Connection.VideoOrientation = AVCaptureVideoOrientation.Portrait;
}
output = new AVCaptureMovieFileOutput();
long totalSeconds = 10000;
Int32 preferredTimeScale = 30;
CMTime maxDuration = new CMTime(totalSeconds, preferredTimeScale);
output.MinFreeDiskSpaceLimit = 1024 * 1024;
output.MaxRecordedDuration = maxDuration;
if (session.CanAddOutput(output))
{
session.AddOutput(output);
}
//Resolutions available @ http://stackoverflow.com/questions/19422322/method-to-find-devices-camera-resolution-ios
session.SessionPreset = AVCaptureSession.PresetHigh; //Widescreen (Medium is 4:3)
Layer.AddSublayer(previewlayer);
//session.StartRunning(); //Moved this to StartPreviewing
}
void ChangeCamera(NSObject sender)
{
//CameraButton.Enabled = false;
//RecordButton.Enabled = false;
//PhotoButton.Enabled = false;
//LivePhotoModeButton.Enabled = false;
//CaptureModeControl.Enabled = false;
sessionQueue.DispatchAsync(() =>
{
var currentVideoDevice = videoDeviceInput.Device;
var currentPosition = currentVideoDevice.Position;
AVCaptureDevicePosition preferredPosition = AVCaptureDevicePosition.Unspecified;
AVCaptureDeviceType preferredDeviceType = AVCaptureDeviceType.BuiltInDualCamera;
switch (currentPosition)
{
//case AVCaptureDevicePosition.Unspecified:
//preferredPosition = AVCaptureDevicePosition.Back;
//preferredDeviceType = AVCaptureDeviceType.BuiltInDualCamera;
//break;
case AVCaptureDevicePosition.Unspecified:
case AVCaptureDevicePosition.Front:
preferredPosition = AVCaptureDevicePosition.Back;
preferredDeviceType = AVCaptureDeviceType.BuiltInDualCamera;
break;
case AVCaptureDevicePosition.Back:
preferredPosition = AVCaptureDevicePosition.Front;
preferredDeviceType = AVCaptureDeviceType.BuiltInWideAngleCamera;
break;
}
var devices = videoDeviceDiscoverySession.Devices;
AVCaptureDevice newVideoDevice = null;
// First, look for a device with both the preferred position and device type.
foreach (var device in devices)
{
if (device.Position == preferredPosition && device.DeviceType.GetConstant() == preferredDeviceType.GetConstant())
{
newVideoDevice = device;
break;
}
}
// Otherwise, look for a device with only the preferred position.
if (newVideoDevice == null)
{
foreach (var device in devices)
{
if (device.Position == preferredPosition)
{
newVideoDevice = device;
break;
}
}
}
if (newVideoDevice != null)
{
var lVideoDeviceInput = AVCaptureDeviceInput.FromDevice(newVideoDevice);
session.BeginConfiguration();
// Remove the existing device input first, since using the front and back camera simultaneously is not supported.
session.RemoveInput(videoDeviceInput);
if (session.CanAddInput(lVideoDeviceInput))
{
if (subjectAreaDidChangeObserver != null)
{
subjectAreaDidChangeObserver.Dispose();
}
subjectAreaDidChangeObserver = NSNotificationCenter.DefaultCenter.AddObserver(AVCaptureDevice.SubjectAreaDidChangeNotification, SubjectAreaDidChange, newVideoDevice);
session.AddInput(lVideoDeviceInput);
videoDeviceInput = lVideoDeviceInput;
}
else
{
session.AddInput(videoDeviceInput);
}
if (movieFileOutput != null)
{
var movieFileOutputConnection = movieFileOutput.ConnectionFromMediaType(AVMediaType.Video);
if (movieFileOutputConnection.SupportsVideoStabilization)
{
movieFileOutputConnection.PreferredVideoStabilizationMode = AVCaptureVideoStabilizationMode.Auto;
}
}
/*
* Set Live Photo capture and depth data delivery if it is supported. When changing cameras, the
* `livePhotoCaptureEnabled` and `depthDataDeliveryEnabled` properties of the AVCapturePhotoOutput gets set to NO when
* a video device is disconnected from the session. After the new video device is
* added to the session, re-enable Live Photo capture and depth data delivery if they are supported.
*/
photoOutput.IsLivePhotoCaptureEnabled = photoOutput.IsLivePhotoCaptureSupported;
//photoOutput.IsDepthDataDeliveryEnabled(photoOutput.IsDepthDataDeliverySupported());
session.CommitConfiguration();
}
//DispatchQueue.MainQueue.DispatchAsync(() =>
//{
// CameraButton.Enabled = true;
// RecordButton.Enabled = CaptureModeControl.SelectedSegment == (int)AVCamCaptureMode.Movie;
// PhotoButton.Enabled = true;
// LivePhotoModeButton.Enabled = true;
// CaptureModeControl.Enabled = true;
// DepthDataDeliveryButton.Enabled = photoOutput.IsDepthDataDeliveryEnabled();
// DepthDataDeliveryButton.Hidden = !photoOutput.IsDepthDataDeliverySupported();
//});
});
}
static bool TryGetDefaultVideoCamera (AVCaptureDeviceType type, AVCaptureDevicePosition position, out AVCaptureDevice device)
{
device = AVCaptureDevice.GetDefaultDevice (type, AVMediaType.Video, position);
return device != null;
}
/// <summary>
/// Videos the device available for passed in position.
/// </summary>
/// <returns>
/// The available device
/// </returns>
/// <param name='position'>
/// The desired Position.
/// </param>
static AVCaptureDevice VideoDeviceWithPosition (AVCaptureDevicePosition position)
{
var devices = AVCaptureDevice.DevicesWithMediaType (AVMediaType.Video);
foreach (var device in devices) {
if (device.Position == position)
return device;
}
return null;
}
static AVCaptureDevice GetDeviceFrom (string mediaType, AVCaptureDevicePosition position)
{
AVCaptureDevice [] devices = AVCaptureDevice.DevicesWithMediaType (mediaType);
AVCaptureDevice captureDevice = devices.FirstOrDefault (d => d.Position == position);
return captureDevice;
}
AVCaptureDevice DeviceWithMediaType(NSString mediaType, AVCaptureDevicePosition position)
{
return(AVCaptureDevice.DevicesWithMediaType(mediaType)
.FirstOrDefault(d => d.Position == position));
}
AVCaptureDevice DeviceWithMediaType (NSString mediaType, AVCaptureDevicePosition position)
{
return AVCaptureDevice.DevicesWithMediaType (mediaType)
.FirstOrDefault (d => d.Position == position);
}
