Issue while capturing the image

[azharuddinsayed]

After calling the method Camera.TakePicture there is no call back from the Camera class ???????????

[tamasbazs]

Hi there,
Thank you for reporting this issue! Could you send us the URL of the given build where you saw this issue?

[azharuddinsayed]

i will share my code with you so that it will be easy for you to debug and find the issue

[azharuddinsayed]

<controls:CameraView x:Name ="Camera" VerticalOptions="FillAndExpand" HorizontalOptions="FillAndExpand" BackgroundColor="Transparent" Opacity="1"/> <artina:Button x:Name="btnCheckIn" Text="In" Style="{StaticResource PrimaryActionButtonStyle}" Grid.Column="0" WidthRequest="{ artina:OnOrientationDouble LandscapePhone=120, LandscapeTablet=240 }" HorizontalOptions="{ artina:OnOrientationLayoutOptions PortraitPhone=Fill, LandscapePhone=Center, PortraitTablet=Fill, LandscapeTablet=Center }" HeightRequest="50" VerticalOptions="Center" TextColor="White" IsEnabled="{Binding IsNotBusy}" Margin="5,0,5,0" BackgroundColor="#1B5E20" Clicked="CaptureImageCheckIn"/> <artina:Button x:Name="btnCheckOut" Text="Out" Style="{StaticResource PrimaryActionButtonStyle}" Grid.Column="1" WidthRequest="{ artina:OnOrientationDouble LandscapePhone=120, LandscapeTablet=240 }" HorizontalOptions="{ artina:OnOrientationLayoutOptions PortraitPhone=Fill, LandscapePhone=Center, PortraitTablet=Fill, LandscapeTablet=Center }" HeightRequest="50" VerticalOptions="Center" TextColor="White" IsEnabled="{Binding IsNotBusy}" BackgroundColor="#F44336" Margin="5,0,5,0" Clicked="CaptureImageCheckOut"/>

[azharuddinsayed]

`
public class CameraView : Xamarin.Forms.View
{
public Func<Task> TakePictureAsync;

    public static readonly BindableProperty CameraProperty = BindableProperty.Create(
        propertyName: "Camera",
        returnType: typeof(CameraOptions),
        declaringType: typeof(CameraView),
        defaultValue: CameraOptions.Rear);

    public CameraOptions Camera
    {
        get { return (CameraOptions)GetValue(CameraProperty); }
        set { SetValue(CameraProperty, value); }
    }
}

//this code is the code behind of the xaml page on button click
protected async void CaptureImageCheckIn(object sender, EventArgs e)
{var picture = await Camera.TakePictureAsync();
}
//camera class
public class Camera
{
static UIImagePickerController picker;
static Action _callback;
static void Init()
{
if (picker != null)
return;

        picker = new UIImagePickerController();//{ SourceType = UIImagePickerControllerSourceType.Camera }; ;
        //picker.FinishedPickingImage += callback();
        picker.Delegate = new CameraDelegate();
    }

    private static EventHandler<UIImagePickerImagePickedEventArgs> callback()
    {
        return (sender, ev) =>
        {
            var filepath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "tmp.png");
            UIImage image = (UIImage)ev.Image;// ObjectForKey(new NSString("UIImagePickerControllerOriginalImage"));
            //picker.Dismi(true);
            //var image = (UIImage)ev.Info.ObjectForKey(new NSString("UIImagePickerControllerOriginalImage"));
        };
    }

    public class CameraDelegate : UIImagePickerControllerDelegate
    {
        public override void FinishedPickingMedia(UIImagePickerController picker, NSDictionary info)
        {
            var originalImg = new NSString("UIImagePickerControllerOriginalImage");
            var image = (UIImage)info[originalImg];
            var imageView = new UIImageView(new RectangleF()); // fill this in!
            imageView.Image = image;
            var cb = _callback;
            _callback = null;

            picker.DismissViewController(true, (Action)null);
            cb(info);
        }
        [Foundation.Export("imagePickerController:didFinishPickingImage:editingInfo:")]
        public override void FinishedPickingImage(UIKit.UIImagePickerController picker, UIKit.UIImage image, Foundation.NSDictionary editingInfo)
        {
            var filepath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "tmp.png");
            //throw new NotImplementedException();
        }

        public override void Canceled(UIImagePickerController picker)
        {
            var cb = _callback;
            _callback = null;

            picker.DismissViewController(true, (Action)null);
            cb(null);
        }
    }
    public static void TakePicture(UIViewController parent, Action<NSDictionary> callback)
    {
        Init();
        picker.SourceType = UIImagePickerControllerSourceType.Camera;
        _callback = callback;
        parent.PresentViewController((UIViewController)picker, true, (Action)null);
    }

    public static void SelectPicture(UIViewController parent, Action<NSDictionary> callback)
    {
        Init();
        picker.SourceType = UIImagePickerControllerSourceType.PhotoLibrary;
        _callback = callback;
        parent.PresentViewController((UIViewController)picker, true, (Action)null);
    }
}

//CameraViewRenderer class
public class CameraViewRenderer : ViewRenderer<CameraView, CameraPreview>
{
CameraPreview uiCameraPreview;
AVCaptureSession captureSession;
AVCaptureDeviceInput captureDeviceInput;
AVCaptureStillImageOutput stillImageOutput;
protected override void OnElementChanged(ElementChangedEventArgs e)
{
base.OnElementChanged(e);
if (e.OldElement != null || Element == null)
{
return;
}
if (Control == null)
{
uiCameraPreview = new CameraPreview(e.NewElement.Camera);
SetNativeControl(new CameraPreview(this.Bounds, this.Element));
SetNativeControl(new CameraPreview());
//uiCameraPreview.SetupEventHandlers();
}
if (e.OldElement != null)
{
// Unsubscribe
if (uiCameraPreview != null)
{
uiCameraPreview.Tapped -= OnCameraPreviewTapped;
}
}
if (e.NewElement != null)
{
// Subscribe
if (uiCameraPreview != null)
{
uiCameraPreview.Tapped += OnCameraPreviewTapped;
}
}
}

    void OnCameraPreviewTapped(object sender, EventArgs e)
    {
        if (uiCameraPreview.IsPreviewing)
        {
            uiCameraPreview.CaptureSession.StopRunning();
            uiCameraPreview.IsPreviewing = false;
        }
        else
        {
            uiCameraPreview.CaptureSession.StartRunning();
            uiCameraPreview.IsPreviewing = true;
        }
    }
    protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        base.OnElementPropertyChanged(sender, e);
        switch (e.PropertyName)
        {
            case "Camera":
                break;
            default:
                break;
        }
    }
    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            Control.CaptureSession.Dispose();
            Control.Dispose();
        }
        base.Dispose(disposing);
    }

}

//CameraPreview class
[Register("CameraPreview")]
public class CameraPreview:UIView
{
private AVCaptureVideoPreviewLayer _previewLayer;
public string LoadErrors { get; private set; }
public bool IsPreviewing { get; set; }
CameraOptions cameraOptions;
public event EventHandler Tapped;
AVCaptureDeviceInput captureDeviceInput;
AVCaptureStillImageOutput stillImageOutput;
UIView liveCameraStream;
UIButton takePhotoButton;
UIButton toggleCameraButton;
UIButton toggleFlashButton;
public AVCaptureSession CaptureSession { get; private set; }
public CameraPreview()
{
Initialize();
}
public CameraPreview(CGRect bounds)
: base(bounds)
{
Initialize();
}
public CameraPreview(CameraOptions options)
{
cameraOptions = options;
IsPreviewing = false;
Initialize();
}
public CameraPreview(CGRect bounds, CameraView element) : base(bounds)
{
element.TakePictureAsync += TakePictureAsync;
}
public Task TakePictureAsync()
{
var tcs = new TaskCompletionSource();
try
{
Camera.TakePicture(UIApplication.SharedApplication.KeyWindow.RootViewController, (imagePickerResult) =>
{
callback(imagePickerResult, tcs);
});
CapturePhoto();
return tcs.Task;
}catch(Exception ex)
{
return null;
}
}

    private static void callback(NSDictionary imagePickerResult, TaskCompletionSource<CapturedImage> tcs)
    {
        if (imagePickerResult == null)
        {
            tcs.TrySetResult(null);
            return;
        }

        var photo = imagePickerResult.ValueForKey(new NSString("UIImagePickerControllerOriginalImage")) as UIImage;

        // You can get photo meta data with using the following
        // var meta = obj.ValueForKey(new NSString("UIImagePickerControllerMediaMetadata")) as NSDictionary;

        var documentsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
        string jpgFilename = Path.Combine(documentsDirectory, Guid.NewGuid() + ".jpeg");
        NSData imgData = photo.AsJPEG();
        NSError err = null;

        if (imgData.Save(jpgFilename, false, out err))
        {
            CapturedImage result = new CapturedImage();
            result.Image = ImageSource.FromStream(imgData.AsStream);
            result.Path = jpgFilename;

            tcs.TrySetResult(result);
        }
        else
        {
            tcs.TrySetException(new Exception(err.LocalizedDescription));
        }
    }

    public override void TouchesBegan(NSSet touches, UIEvent evt)
    {
        base.TouchesBegan(touches, evt);
        OnTapped();
    }

    protected virtual void OnTapped()
    {
        var eventHandler = Tapped;
        if (eventHandler != null)
        {
            eventHandler(this, new EventArgs());
        }
    }
    public override void Draw(CGRect rect)
    {
        base.Draw(rect);
        _previewLayer.Frame = rect;
    }

    async void AuthorizeCameraUse()
    {
        var authorizationStatus = AVCaptureDevice.GetAuthorizationStatus(AVMediaType.Video);
        if (authorizationStatus != AVAuthorizationStatus.Authorized)
        {
            await AVCaptureDevice.RequestAccessForMediaTypeAsync(AVMediaType.Video);
        }
    }
    void ConfigureCameraForDevice(AVCaptureDevice device)
    {
        var error = new NSError();
        if (device.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
        {
            device.LockForConfiguration(out error);
            device.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
            device.UnlockForConfiguration();
        }
        else if (device.IsExposureModeSupported(AVCaptureExposureMode.ContinuousAutoExposure))
        {
            device.LockForConfiguration(out error);
            device.ExposureMode = AVCaptureExposureMode.ContinuousAutoExposure;
            device.UnlockForConfiguration();
        }
        else if (device.IsWhiteBalanceModeSupported(AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance))
        {
            device.LockForConfiguration(out error);
            device.WhiteBalanceMode = AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance;
            device.UnlockForConfiguration();
        }
    }
    void SetupLiveCameraStream()
    {
        try
        {
            if (CaptureSession == null)
                CaptureSession = new AVCaptureSession();

            //var viewLayer = liveCameraStream.Layer;
            //var videoPreviewLayer = new AVCaptureVideoPreviewLayer(CaptureSession)
            //{
            //    Frame = liveCameraStream.Bounds
            //};
            //_previewLayer = new AVCaptureVideoPreviewLayer(CaptureSession)
            //{
            //    VideoGravity = AVLayerVideoGravity.ResizeAspectFill,

            //    Frame = Bounds
            //};
            //liveCameraStream.Layer.AddSublayer(_previewLayer);

            var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
            //ConfigureCameraForDevice(captureDevice);
            captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);

            var dictionary = new NSMutableDictionary();
            dictionary[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG);
            stillImageOutput = new AVCaptureStillImageOutput()
            {
                OutputSettings = new NSDictionary()
            };

            CaptureSession.AddOutput(stillImageOutput);
            //CaptureSession.AddInput(captureDeviceInput);
            CaptureSession.StartRunning();
        }catch(Exception ex)
        {

        }
    }
    void ToggleFlash()
    {
        var device = captureDeviceInput.Device;

        var error = new NSError();
        if (device.HasFlash)
        {
            if (device.FlashMode == AVCaptureFlashMode.On)
            {
                device.LockForConfiguration(out error);
                device.FlashMode = AVCaptureFlashMode.Off;
                device.UnlockForConfiguration();
                toggleFlashButton.SetBackgroundImage(UIImage.FromFile("NoFlashButton.png"), UIControlState.Normal);
            }
            else
            {
                device.LockForConfiguration(out error);
                device.FlashMode = AVCaptureFlashMode.On;
                device.UnlockForConfiguration();
                toggleFlashButton.SetBackgroundImage(UIImage.FromFile("FlashButton.png"), UIControlState.Normal);
            }
        }
    }

    AVCaptureDevice GetCameraForOrientation(AVCaptureDevicePosition orientation)
    {
        var devices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);

        foreach (var device in devices)
        {
            if (device.Position == orientation)
            {
                return device;
            }
        }
        return null;
    }
    async void CapturePhoto()
    {
        try
        {
            if (this.stillImageOutput == null)
            {
                this.stillImageOutput = new AVCaptureStillImageOutput()
                {
                    OutputSettings = new NSDictionary()
                };
            }
            var videoConnection = this.stillImageOutput.ConnectionFromMediaType(AVMediaType.Video);
            var sampleBuffer = await stillImageOutput.CaptureStillImageTaskAsync(videoConnection);
            var jpegImage = AVCaptureStillImageOutput.JpegStillToNSData(sampleBuffer);

            var photo = new UIImage(jpegImage);
            photo.SaveToPhotosAlbum((image, error) =>
            {
                Console.Error.WriteLine(@"				Error: ", error);
            });
        }catch(Exception ex)
        {

        }
    }

    void ToggleFrontBackCamera()
    {
        var devicePosition = captureDeviceInput.Device.Position;
        if (devicePosition == AVCaptureDevicePosition.Front)
        {
            devicePosition = AVCaptureDevicePosition.Back;
        }
        else
        {
            devicePosition = AVCaptureDevicePosition.Front;
        }

        var device = GetCameraForOrientation(devicePosition);
        ConfigureCameraForDevice(device);

        CaptureSession.BeginConfiguration();
        CaptureSession.RemoveInput(captureDeviceInput);
        captureDeviceInput = AVCaptureDeviceInput.FromDevice(device);
        CaptureSession.AddInput(captureDeviceInput);
        CaptureSession.CommitConfiguration();
    }
    

   public void SetupEventHandlers()
    {
        takePhotoButton.TouchUpInside += (object sender, EventArgs e) => {
            CapturePhoto();
        };

        toggleCameraButton.TouchUpInside += (object sender, EventArgs e) => {
            ToggleFrontBackCamera();
        };

        toggleFlashButton.TouchUpInside += (object sender, EventArgs e) => {
            ToggleFlash();
        };
    }

    private void Initialize()
    {
        CaptureSession = new AVCaptureSession();
        _previewLayer = new AVCaptureVideoPreviewLayer(CaptureSession)
        {
            VideoGravity = AVLayerVideoGravity.ResizeAspectFill,

            Frame = Bounds
        };
        // create a device input and attach it to the session
        AVCaptureDevice frontCameraDevice = MediaDevices.FrontCamera;
        if (frontCameraDevice == null)
        {
            LoadErrors = "Cannot load camera";
            return;
        }

        try
        {
            NSError error = null;
            frontCameraDevice.LockForConfiguration(out error);
            if (error != null)
            {
                Debug.WriteLine(error);
                //throw new BusinessLogicException (ErrorCode.EC_UNDEFINED_ERROR, error.ToString());
                //TODO: show error to user
            }
            frontCameraDevice.ActiveVideoMinFrameDuration = new CMTime(1, 15); // Configure for 15 FPS
        }
        finally
        {
            frontCameraDevice.UnlockForConfiguration();
        }

        AVCaptureDeviceInput inputDevice = AVCaptureDeviceInput.FromDevice(frontCameraDevice);

        if (inputDevice == null)
        {
            LoadErrors = "Cannot access front camera";
            return;
        }

        CaptureSession.AddInput(inputDevice);
        //ConfigureCameraForDevice(inputDevice);
        NSError errorOut;

        Layer.AddSublayer(_previewLayer);
        SetupLiveCameraStream();
        //CaptureSession.StartRunning();
    }
}

`
please see the above code which i have written for my ios and there is call back after TakePicture call

[tamasbazs]

Just to be sure, were you running the code on your machine using the simulator and there were no issues? Also, do you have a check for availability of the camera?

[azharuddinsayed]

i am testing the code on iphone 5s and i have not checked the availability of the camera but camera renderer is not an issue it is rendering the camera but the button click is not working .please help me as i stuck at that point only.

[godrei]

Hi @azharuddinsayed,

we use our sample projects to test our system. This means for sample apps we focus on project settings and to keep it buildable or to be able to test what we want to.

So because of this, we do not really care about this project as a real-life mobile application.

May I ask you for what do you use this project?