HOW TO: Use Leadtools.Camera.Xamarin's AutoCapture Class

using Leadtools;
using Leadtools.Camera.Xamarin;
using System.Diagnostics;
using System.Timers;
using Xamarin.Forms;

namespace AutoCaptureExample
{
   public partial class MainPage : ContentPage
   {
      private AutoCapture autoCapture;
      private bool holding = false; // flag indicating whether we're in the "hold still" phase
      private bool shouldCheckStability = false; // flag indicating whether we should check the hold stability, potentially invalidating the "hold still" phase
      private bool isCapturing = false; // flag indicating whether we are currently taking a picture
      private bool cameraFocused = false; // flag indicating whether the camera has been focused
      private Timer checkHoldStabilityTimer;
      private Stopwatch captureStopwatch;

      public MainPage()
      {
         string licString = ""; // TODO: your license goes here
         string key = ""; // TODO: your developer key goes here
         byte[] licBytes = System.Text.Encoding.UTF8.GetBytes(licString);
         RasterSupport.SetLicense(licBytes, key);

         InitializeComponent();

         // initialize autocapture
         autoCapture = new AutoCapture();
         // use text detection mode
         autoCapture.CaptureMethod = AutoCapture.AutoCaptureMethod.TextDetection;

         // set up a timer so we can check "hold stability" every 300ms
         checkHoldStabilityTimer = new System.Timers.Timer();
         checkHoldStabilityTimer.Interval = 300;
         checkHoldStabilityTimer.Elapsed += (s, _e) => { shouldCheckStability = true; }; // just resets the flag saying we should check it
         checkHoldStabilityTimer.AutoReset = true; // repeats the timer
         checkHoldStabilityTimer.Enabled = true; // enables the timer
         captureStopwatch = new Stopwatch(); // initializes the stopwatch we use to make sure the camera is stable for long enough

         leadCamera.FrameReceived += FrameReceivedHandler; // register the frame received handler
         leadCamera.FocusCompleted += FocusCompletedHandler; // register the focus completed handler
         leadCamera.PictureReceived += PictureReceivedHandler; // register the picture received handler
      }

      protected override void OnAppearing()
      {
         base.OnAppearing();
         leadCamera.Camera.FocusMode = FocusMode.Continuous; // we're going to use continuous mode until we've found a document
      }

      private void PictureReceivedHandler(FrameHandlerEventArgs e)
      {
         // we received a picture!
         leadCamera.Camera.FocusMode = FocusMode.Continuous; // reset focus mode
         cameraFocused = false; // reset our focus flag
         autoCapture.Reset(); // reset autocapture values
         holding = false; // move out of "hold still" phase
         isCapturing = false; // we aren't waiting on any picture anymore
         shouldCheckStability = false; // we shouldn't check hold stability right away

         Device.BeginInvokeOnMainThread(() =>
         {
            stabilityLabel.Text = ""; // update label and display an alert
            DisplayAlert("Picture taken", "Took a picture", "Ok");
         });

         // TODO: do whatever you want with e.Image!

         e.Image.Dispose();
      }

      private void FocusCompletedHandler(Leadtools.Camera.Xamarin.FocusEventArgs e)
      {
         cameraFocused = true; // the camera is focused
      }

      private void FrameReceivedHandler(FrameHandlerEventArgs e)
      {
         if (e.Image == null) return; // make sure we actually have a frame to check
         if (!holding)
         {
            // if we AREN'T in "hold still" phase, let's check if the image is stable at all
            autoCapture.CheckStability(e.Image);
         }
         if (holding && shouldCheckStability)
         {
            // if we ARE in "hold still" phase and we need to check if we're still stable, let's do so
            // since shouldCheckStability is set to true every 300ms, this will only be reached once every 300ms

            shouldCheckStability = false; // reset the flag, we only need to do this once
            bool stable = autoCapture.CheckHoldStability(e.Image); // check the hold stability

            if (!stable) // if we're not stable, we need to move back out of "hold still" phase
            {
               holding = false; // move out of phase
               autoCapture.Reset(); // reset our autocapture
               captureStopwatch.Reset(); // reset the timer
               Device.BeginInvokeOnMainThread(() =>
               {
                  stabilityLabel.Text = ""; // reset our label
               });
               e.Image.Dispose();
               return;
            }
            else if (cameraFocused && captureStopwatch.ElapsedMilliseconds > 1500 && !isCapturing)
            {
               // image has been stable for a while (1500ms), image is focused, and we're not currently waiting on an image from the camera
               leadCamera.Camera.TakePicture();
               isCapturing = true; // make sure we don't call TakePicture() again until we've gotten our image from the camera
               Device.BeginInvokeOnMainThread(() =>
               {
                  stabilityLabel.Text = "Taking picture..."; // update our label to reflect that we're taking a picture
                  stabilityLabel.TextColor = Color.Green;
               });
            }
         }

         // if we AREN'T in "hold still" phase, but the camera is stable, let's move into "hold still" phase
         if (autoCapture.IsStable && !holding)
         {
            holding = true; // move in to "hold still"
            captureStopwatch.Reset(); // reset the capture stopwatch
            captureStopwatch.Start(); // start it so we can measure how long the camera has been stable
            cameraFocused = false; // reset focus flag
            leadCamera.Camera.FocusMode = FocusMode.Auto; // switch to auto mode so we can direct the camera to refocus manually
            leadCamera.Camera.Focus(); // tell camera to refocus
            Device.BeginInvokeOnMainThread(() =>
            {
               stabilityLabel.Text = "Hold still..."; // prompt user to hold still
               stabilityLabel.TextColor = Color.DarkOrange;
            });
         }

         e.Image.Dispose(); // release the frame
      }
   }
}

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:AutoCaptureExample"
             xmlns:leadtools="clr-namespace:Leadtools.Camera.Xamarin;assembly=Leadtools.Camera.Xamarin"
             x:Class="AutoCaptureExample.MainPage">

   <StackLayout>
      <leadtools:CameraView x:Name="leadCamera" HorizontalOptions="FillAndExpand" VerticalOptions="FillAndExpand"/>
      <Label x:Name="stabilityLabel" FontSize="Large" HorizontalTextAlignment="Center"/>
   </StackLayout>
</ContentPage>