From ec2e08f19e5fe2309fbaa87dc63504af07014bac Mon Sep 17 00:00:00 2001
From: scottm <scottm@scope-services.com>
Date: Mon, 20 Apr 2020 14:47:47 -0400
Subject: [PATCH] Add support for reducing the scanning area to the bounds of a
 specific View.  Many users need to scan barcodes that are close together. 
 This update allows those barcodes to be easily scanned.  Add additional logic
 to Sample.Android project to demonstrate new capability.

---
 .../FragmentActivityCustomScanArea.cs         | 317 ++++++++++++++++++
 Samples/Sample.Android/MainActivity.cs        | 261 +++++++++++++-
 .../Resources/drawable/magnify_minus.png      | Bin 0 -> 829 bytes
 .../Resources/drawable/magnify_plus.png       | Bin 0 -> 824 bytes
 .../Resources/drawable/scanborder.xml         |   4 +
 .../Sample.Android/Resources/layout/Main.axml |  16 +-
 .../layout/ZxingOverlayCustomScanArea.xml     | 119 +++++++
 .../Resources/values/colors.xml               |   7 +
 Samples/Sample.Android/Sample.Android.csproj  |  18 +-
 .../CameraAccess/CameraAnalyzer.android.cs    | 233 +++++++++++--
 .../CameraAccess/CameraController.android.cs  | 123 ++++---
 .../Android/MobileBarcodeScanner.android.cs   |   4 +-
 .../Android/ZXingScannerFragment.android.cs   |  22 +-
 .../Android/ZXingSurfaceView.android.cs       |  13 +
 .../Android/ZxingActivity.android.cs          |  12 +-
 15 files changed, 1052 insertions(+), 97 deletions(-)
 create mode 100644 Samples/Sample.Android/FragmentActivityCustomScanArea.cs
 create mode 100644 Samples/Sample.Android/Resources/drawable/magnify_minus.png
 create mode 100644 Samples/Sample.Android/Resources/drawable/magnify_plus.png
 create mode 100644 Samples/Sample.Android/Resources/drawable/scanborder.xml
 create mode 100644 Samples/Sample.Android/Resources/layout/ZxingOverlayCustomScanArea.xml
 create mode 100644 Samples/Sample.Android/Resources/values/colors.xml

diff --git a/Samples/Sample.Android/FragmentActivityCustomScanArea.cs b/Samples/Sample.Android/FragmentActivityCustomScanArea.cs
new file mode 100644
index 000000000..322c0f4b3
--- /dev/null
+++ b/Samples/Sample.Android/FragmentActivityCustomScanArea.cs
@@ -0,0 +1,317 @@
+using System;
+using System.Collections.Generic;
+using ZXing.Mobile;
+using Android.OS;
+
+using Android.App;
+using Android.Widget;
+using Android.Content.PM;
+using Android.Views;
+using Xamarin.Essentials;
+using Android.Content;
+using AndroidX.ConstraintLayout.Widget;
+
+namespace Sample.Android
+{
+    [Activity(Label = "ZXing.Net.Mobile", Theme = "@style/Theme.AppCompat.Light", ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.KeyboardHidden)]
+    public class FragmentActivityCustomScanArea : AndroidX.Fragment.App.FragmentActivity
+    {
+		ZXingScannerFragment scanFragment;
+        Button buttonRectangle;
+        Button buttonSquare;
+        Button buttonRandom;
+        ImageButton buttonIncrease;
+        ImageButton buttonDecrease;
+        ToggleButton scanViewPosition;
+        View scanArea;
+        bool scanAreaIsRectangle = true;
+        bool isScanAreaCentered = false;
+
+        protected override void OnCreate (Bundle savedInstanceState)
+		{
+			base.OnCreate (savedInstanceState);
+
+            SetContentView (Resource.Layout.FragmentActivity);
+
+		}
+
+        protected override void OnResume ()
+        {
+            base.OnResume ();
+
+
+            if (scanFragment == null)
+            {
+                var zxingOverlay = LayoutInflater.FromContext(this).Inflate(Resource.Layout.ZxingOverlayCustomScanArea, null);
+                scanArea = zxingOverlay.FindViewById<View>(Resource.Id.scanView);
+
+                //Find all the buttons and wire up their events
+                buttonRectangle = zxingOverlay.FindViewById<Button>(Resource.Id.buttonSquareScanRectangle);
+                buttonSquare = zxingOverlay.FindViewById<Button>(Resource.Id.buttonSquareScanView);
+                scanViewPosition = zxingOverlay.FindViewById<ToggleButton>(Resource.Id.toggleButtonScanViewLocation);
+                buttonIncrease = zxingOverlay.FindViewById<ImageButton>(Resource.Id.buttonIncrease);
+                buttonDecrease = zxingOverlay.FindViewById<ImageButton>(Resource.Id.buttonDecrease);
+                buttonRandom = zxingOverlay.FindViewById<Button>(Resource.Id.buttonRandom);
+
+                buttonRectangle.Click += Rectangle_Click;
+                buttonSquare.Click += Square_Click;
+                scanViewPosition.Click += ScanViewPosition_Click;
+                buttonIncrease.Click += ButtonIncrease_Click;
+                buttonDecrease.Click += ButtonDecrease_Click;
+                buttonRandom.Click += ButtonRandom_Click;
+
+                scanFragment = new ZXingScannerFragment(zxingOverlay, true, scanArea);                   
+
+                SupportFragmentManager.BeginTransaction()
+                    .Replace(Resource.Id.fragment_container, scanFragment)
+                    .Commit();
+            }
+
+                Scan();
+        }
+
+        public override void OnRequestPermissionsResult(int requestCode, string[] permissions, Permission[] grantResults)
+            => Xamarin.Essentials.Platform.OnRequestPermissionsResult(requestCode, permissions, grantResults);
+
+        protected override void OnPause()
+        {
+            scanFragment?.StopScanning();
+
+            base.OnPause();
+        }
+
+        void Scan ()
+        {
+            var opts = new MobileBarcodeScanningOptions {
+                
+                CameraResolutionSelector = availableResolutions => {
+
+                    foreach (var ar in availableResolutions) {
+                        Console.WriteLine ("Resolution: " + ar.Width + "x" + ar.Height);
+                    }
+                    return null;
+                }
+            };
+
+            scanFragment.StartScanning(result => {
+
+                var resultIntent = new Intent();
+                string resultText;
+                // Null result means scanning was cancelled
+                if (result == null || string.IsNullOrEmpty (result.Text)) {
+                    resultText = "";
+                }
+               else
+                {
+                    resultText = result.Text;
+                }
+                // Otherwise, proceed with result
+                
+                resultIntent.PutExtra(Activity1.RESULT_EXTRA_NAME, resultText);
+                SetResult(Result.Ok, resultIntent);
+                Finish();
+            }, opts);
+        }
+
+        void ButtonRandom_Click(object sender, EventArgs e)
+        {
+            buttonRandom.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            var rand = new Random();
+
+            var layoutParams = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+
+            if (scanAreaIsRectangle)
+            {
+                var moveUp = rand.Next(0, 100) % 2 == 0;
+
+                if (isScanAreaCentered)
+                {
+                    if (moveUp)
+                    {
+                        layoutParams.BottomMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                        layoutParams.LeftMargin = rand.Next(0, parentLayout.Width - scanArea.Width);
+                    }
+                    else
+                    {
+                        layoutParams.TopMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                        layoutParams.RightMargin = rand.Next(0, parentLayout.Width - scanArea.Width);
+                    }
+                }
+                else
+                {
+                    if (moveUp)
+                    {
+                        layoutParams.BottomMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                    }
+                    else
+                        layoutParams.TopMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                }
+            }
+            else
+            {
+                var moveUp = rand.Next(0, 100) % 2 == 0;
+
+                if (moveUp)
+                {
+                    layoutParams.BottomMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                    layoutParams.LeftMargin = rand.Next(0, parentLayout.Width - scanArea.Width);
+                }
+                else
+                {
+                    layoutParams.TopMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                    layoutParams.RightMargin = rand.Next(0, parentLayout.Width - scanArea.Width);
+                }
+            }
+            scanArea.LayoutParameters = layoutParams;
+        }
+
+        void ButtonDecrease_Click(object sender, EventArgs e)
+        {
+            buttonDecrease.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            var layout = scanArea.LayoutParameters;
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            var height = layout.Height;
+            var width = layout.Width;
+            height = (int)(height * .9);
+            width = (int)(width * .9);
+            if (height > parentLayout.Height) height = parentLayout.Height;
+            if (width > parentLayout.Width) width = parentLayout.Width;
+            layout.Height = height;
+            layout.Width = width;
+            scanArea.LayoutParameters = layout;
+        }
+
+        void ButtonIncrease_Click(object sender, EventArgs e)
+        {
+            buttonIncrease.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            var layout = scanArea.LayoutParameters;
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            var height = layout.Height;
+            var width = layout.Width;
+            height = (int)(height * 1.1);
+            width = (int)(width * 1.1);
+            if (height > parentLayout.Height) height = parentLayout.Height;
+            if (width > parentLayout.Width) width = parentLayout.Width;
+            layout.Height = height;
+            layout.Width = width;
+            scanArea.LayoutParameters = layout;
+        }
+
+        int ConvertDpToPx(int dp)
+        {
+            var density = ApplicationContext.Resources
+                                   .DisplayMetrics
+                                   .Density;
+            return (int)Math.Round(dp * density + .5f);
+        }
+
+        void ScanViewPosition_Click(object sender, EventArgs e)
+        {
+            scanViewPosition.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            isScanAreaCentered = scanViewPosition.Checked;
+
+            if (scanAreaIsRectangle)
+            {
+                if (isScanAreaCentered) SetRectangleCentered();
+                else SetRectangleFullWidth();
+            }
+            else if (isScanAreaCentered) SetSquareCentered();
+            else SetSquareFullWidth();
+        }
+
+        void Square_Click(object sender, EventArgs e)
+        {
+            buttonSquare.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            if (scanViewPosition.Checked)
+            {
+                SetSquareCentered();
+            }
+            else
+            {
+                SetSquareFullWidth();
+            }
+        }
+
+        void Rectangle_Click(object sender, EventArgs e)
+        {
+            buttonRectangle.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            if (scanViewPosition.Checked)
+            {
+                SetRectangleCentered();
+            }
+            else
+            {
+                SetRectangleFullWidth();
+            }
+        }
+
+        void SetRectangleCentered()
+        {
+            var layout = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+            layout.MarginEnd = 0;
+            layout.LeftMargin = 0;
+            layout.RightMargin = 0;
+            layout.TopMargin = 0;
+
+            layout.Height = ConvertDpToPx(75);
+            layout.Width = ConvertDpToPx(150);
+            scanArea.LayoutParameters = layout;
+            isScanAreaCentered = true;
+            scanAreaIsRectangle = true;
+        }
+
+        void SetRectangleFullWidth()
+        {
+            var layout = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+            layout.MarginEnd = 0;
+            layout.LeftMargin = 0;
+            layout.RightMargin = 0;
+            layout.TopMargin = 0;
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            layout.Height = ConvertDpToPx(120);
+            layout.Width = parentLayout.Width;
+            scanArea.LayoutParameters = layout;
+            isScanAreaCentered = false;
+            scanAreaIsRectangle = true;
+        }
+
+        void SetSquareCentered()
+        {
+            var layout = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+            layout.MarginEnd = 0;
+            layout.LeftMargin = 0;
+            layout.RightMargin = 0;
+            layout.TopMargin = 0;
+            layout.Height = ConvertDpToPx(120);
+            layout.Width = ConvertDpToPx(120);
+            scanArea.LayoutParameters = layout;
+            isScanAreaCentered = true;
+            scanAreaIsRectangle = false;
+        }
+
+        void SetSquareFullWidth()
+        {
+            var layout = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+            layout.MarginEnd = 0;
+            layout.LeftMargin = 0;
+            layout.RightMargin = 0;
+            layout.TopMargin = 0;
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            if (DeviceDisplay.MainDisplayInfo.Orientation == DisplayOrientation.Landscape)
+            {
+                layout.Height = parentLayout.Height;
+                layout.Width = parentLayout.Height;
+            }
+            else
+            {
+                layout.Height = parentLayout.Width;
+                layout.Width = parentLayout.Width;
+            }
+            scanArea.LayoutParameters = layout;
+            isScanAreaCentered = false;
+            scanAreaIsRectangle = false;
+        }
+    }
+}
+
diff --git a/Samples/Sample.Android/MainActivity.cs b/Samples/Sample.Android/MainActivity.cs
index 0d5f17364..ab322f572 100644
--- a/Samples/Sample.Android/MainActivity.cs
+++ b/Samples/Sample.Android/MainActivity.cs
@@ -7,6 +7,8 @@
 using ZXing;
 using ZXing.Mobile;
 using System;
+using Xamarin.Essentials;
+using AndroidX.ConstraintLayout.Widget;
 
 namespace Sample.Android
 {
@@ -14,13 +16,28 @@ namespace Sample.Android
 	public class Activity1 : AndroidX.AppCompat.App.AppCompatActivity
 	{
 		Button buttonScanCustomView;
+		Button buttonScanCustomAreaView;
 		Button buttonScanDefaultView;
 		Button buttonContinuousScan;
 		Button buttonFragmentScanner;
+        Button buttonFragmentScannerCustomArea;
 		Button buttonGenerate;
 
 		MobileBarcodeScanner scanner;
 
+        //custom scan area variables
+        Button buttonRectangle;
+        Button buttonSquare;
+        Button buttonRandom;
+        ImageButton buttonIncrease;
+        ImageButton buttonDecrease;
+        ToggleButton scanViewPosition;
+        View scanArea;
+        bool scanAreaIsRectangle = true;
+        bool isScanAreaCentered = false;
+        const int FRAGMENT_SCAN_REQUEST = 1;
+        public const string RESULT_EXTRA_NAME = "scanResultText";
+
 		protected override void OnCreate(Bundle bundle)
 		{
 			base.OnCreate(bundle);
@@ -86,6 +103,7 @@ protected override void OnCreate(Bundle bundle)
 
 				//Set our custom overlay
 				scanner.CustomOverlay = zxingOverlay;
+                scanner.UseCustomOverlay = true;
 
 				//Start scanning!
 				var result = await scanner.Scan(new MobileBarcodeScanningOptions { AutoRotate = true });
@@ -93,12 +111,53 @@ protected override void OnCreate(Bundle bundle)
 				HandleScanResult(result);
 			};
 
+			buttonScanCustomAreaView = this.FindViewById<Button>(Resource.Id.buttonScanCustomAreaView);
+			buttonScanCustomAreaView.Click += async delegate {
+
+				//Tell our scanner we want to use a custom overlay instead of the default
+				scanner.UseCustomOverlay = true;
+
+				//Inflate our custom overlay from a resource layout
+				zxingOverlay = LayoutInflater.FromContext(this).Inflate(Resource.Layout.ZxingOverlayCustomScanArea, null);                
+                scanArea = zxingOverlay.FindViewById<View>(Resource.Id.scanView);
+
+                //Find all the buttons and wire up their events
+                buttonRectangle = zxingOverlay.FindViewById<Button>(Resource.Id.buttonSquareScanRectangle);
+                buttonSquare = zxingOverlay.FindViewById<Button>(Resource.Id.buttonSquareScanView);
+                scanViewPosition = zxingOverlay.FindViewById<ToggleButton>(Resource.Id.toggleButtonScanViewLocation);
+                buttonIncrease = zxingOverlay.FindViewById<ImageButton>(Resource.Id.buttonIncrease);
+                buttonDecrease = zxingOverlay.FindViewById<ImageButton>(Resource.Id.buttonDecrease);
+                buttonRandom = zxingOverlay.FindViewById<Button>(Resource.Id.buttonRandom);
+
+                buttonRectangle.Click += Rectangle_Click;
+                buttonSquare.Click += Square_Click;
+                scanViewPosition.Click += ScanViewPosition_Click;                
+                buttonIncrease.Click += ButtonIncrease_Click;
+                buttonDecrease.Click += ButtonDecrease_Click;
+                buttonRandom.Click += ButtonRandom_Click;
+
+                //Set our custom overlay and custom scan area
+                scanner.CustomOverlay = zxingOverlay;
+                scanner.UseCustomOverlay = true;
+                scanner.CustomOverlayScanAreaView = scanArea;
+
+                //Start scanning!
+                var result = await scanner.Scan(new MobileBarcodeScanningOptions { AutoRotate = true });
+
+				HandleScanResult(result);
+			};
+
 			buttonFragmentScanner = FindViewById<Button>(Resource.Id.buttonFragment);
 			buttonFragmentScanner.Click += delegate
 			{
 				StartActivity(typeof(FragmentActivity));
 			};
 
+            buttonFragmentScannerCustomArea = FindViewById<Button>(Resource.Id.buttonFragmentCustomArea);
+            buttonFragmentScannerCustomArea.Click += delegate {                                
+                StartActivityForResult(typeof(FragmentActivityCustomScanArea), FRAGMENT_SCAN_REQUEST);                                    
+            };
+
 			buttonGenerate = FindViewById<Button>(Resource.Id.buttonGenerate);
 			buttonGenerate.Click += delegate
 			{
@@ -164,7 +223,207 @@ public Java.Lang.String UITestBackdoorScan(string param)
 
 			return new Java.Lang.String();
 		}
-	}
+
+        void ButtonRandom_Click(object sender, EventArgs e)
+        {
+            buttonRandom.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            var rand = new Random();
+
+            var layoutParams = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+
+            if (scanAreaIsRectangle)
+            {
+                var moveUp = rand.Next(0, 100) % 2 == 0;
+
+                if (isScanAreaCentered)
+                {
+                    if (moveUp)
+                    {
+                        layoutParams.BottomMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                        layoutParams.LeftMargin = rand.Next(0, parentLayout.Width - scanArea.Width);
+                    }
+                    else
+                    {
+                        layoutParams.TopMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                        layoutParams.RightMargin = rand.Next(0, parentLayout.Width - scanArea.Width);
+                    }
+                }
+                else
+                {
+                    if (moveUp)
+                    {
+                        layoutParams.BottomMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                    }
+                    else
+                        layoutParams.TopMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                }
+            }
+            else
+            {
+                var moveUp = rand.Next(0, 100) % 2 == 0;
+
+                if (moveUp)
+                {
+                    layoutParams.BottomMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                    layoutParams.LeftMargin = rand.Next(0, parentLayout.Width - scanArea.Width);
+                }
+                else
+                {
+                    layoutParams.TopMargin = rand.Next(0, parentLayout.Height - scanArea.Height);
+                    layoutParams.RightMargin = rand.Next(0, parentLayout.Width - scanArea.Width);
+                }
+            }
+            scanArea.LayoutParameters = layoutParams;
+        }
+
+        void ButtonDecrease_Click(object sender, EventArgs e)
+        {
+            buttonDecrease.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            var layout = scanArea.LayoutParameters;
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            var height = layout.Height;
+            var width = layout.Width;
+            height = (int)(height * .9);
+            width = (int)(width * .9);
+            if (height > parentLayout.Height) height = parentLayout.Height;
+            if (width > parentLayout.Width) width = parentLayout.Width;
+            layout.Height = height;
+            layout.Width = width;
+            scanArea.LayoutParameters = layout;
+        }
+
+        void ButtonIncrease_Click(object sender, EventArgs e)
+        {
+            buttonIncrease.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            var layout = scanArea.LayoutParameters;
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            var height = layout.Height;
+            var width = layout.Width;
+            height = (int)(height * 1.1);
+            width = (int)(width * 1.1);
+            if (height > parentLayout.Height) height = parentLayout.Height;
+            if (width > parentLayout.Width) width = parentLayout.Width;
+            layout.Height = height;
+            layout.Width = width;
+            scanArea.LayoutParameters = layout;
+        }
+
+        public int ConvertDpToPx(int dp)
+        {
+            var density = ApplicationContext.Resources
+                                   .DisplayMetrics
+                                   .Density;
+            return (int)Math.Round(dp * density + .5f);
+        }
+
+        void ScanViewPosition_Click(object sender, EventArgs e)
+        {
+            scanViewPosition.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            isScanAreaCentered = scanViewPosition.Checked;
+
+            if (scanAreaIsRectangle)
+            {
+                if (isScanAreaCentered) SetRectangleCentered();
+                else SetRectangleFullWidth();
+            }
+            else if (isScanAreaCentered) SetSquareCentered();
+            else SetSquareFullWidth();
+        }
+
+        void Square_Click(object sender, EventArgs e)
+        {
+            buttonSquare.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            if (scanViewPosition.Checked)
+            {
+                SetSquareCentered();
+            }
+            else
+            {
+                SetSquareFullWidth();
+            }
+        }
+
+        void Rectangle_Click(object sender, EventArgs e)
+        {
+            buttonRectangle.PerformHapticFeedback(FeedbackConstants.KeyboardTap);
+            if (scanViewPosition.Checked)
+            {
+                SetRectangleCentered();
+            }
+            else
+            {
+                SetRectangleFullWidth();
+            }
+        }
+
+        void SetRectangleCentered()
+        {
+            var layout = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+            layout.MarginEnd = 0;
+            layout.LeftMargin = 0;
+            layout.RightMargin = 0;
+            layout.TopMargin = 0;
+
+            layout.Height = ConvertDpToPx(75);
+            layout.Width = ConvertDpToPx(150);
+            scanArea.LayoutParameters = layout;
+            isScanAreaCentered = true;
+            scanAreaIsRectangle = true;
+        }
+
+        void SetRectangleFullWidth()
+        {
+            var layout = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+            layout.MarginEnd = 0;
+            layout.LeftMargin = 0;
+            layout.RightMargin = 0;
+            layout.TopMargin = 0;
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            layout.Height = ConvertDpToPx(120);
+            layout.Width = parentLayout.Width;
+            scanArea.LayoutParameters = layout;
+            isScanAreaCentered = false;
+            scanAreaIsRectangle = true;
+        }
+
+        void SetSquareCentered()
+        {
+            var layout = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+            layout.MarginEnd = 0;
+            layout.LeftMargin = 0;
+            layout.RightMargin = 0;
+            layout.TopMargin = 0;
+            layout.Height = ConvertDpToPx(120);
+            layout.Width = ConvertDpToPx(120);
+            scanArea.LayoutParameters = layout;
+            isScanAreaCentered = true;
+            scanAreaIsRectangle = false;
+        }
+
+        void SetSquareFullWidth()
+        {
+            var layout = (ViewGroup.MarginLayoutParams)scanArea.LayoutParameters;
+            layout.MarginEnd = 0;
+            layout.LeftMargin = 0;
+            layout.RightMargin = 0;
+            layout.TopMargin = 0;
+            var parentLayout = (ConstraintLayout)scanArea.Parent;
+            if (DeviceDisplay.MainDisplayInfo.Orientation == DisplayOrientation.Landscape)
+            {
+                layout.Height = parentLayout.Height;
+                layout.Width = parentLayout.Height;
+            }
+            else
+            {
+                layout.Height = parentLayout.Width;
+                layout.Width = parentLayout.Width;
+            }
+            scanArea.LayoutParameters = layout;
+            isScanAreaCentered = false;
+            scanAreaIsRectangle = false;
+        }
+    }
 }
 
 
diff --git a/Samples/Sample.Android/Resources/drawable/magnify_minus.png b/Samples/Sample.Android/Resources/drawable/magnify_minus.png
new file mode 100644
index 0000000000000000000000000000000000000000..103b5a0ef7caa0eb486e57593a0c67c125416a34
GIT binary patch
literal 829
zcmeAS@N?(olHy`uVBq!ia0vp^1|ZDA1|-9oezpTCmUKs7M+SzC{oH>NS%G}U;vjb?
zhIQv;UIIA^$sR$z3=CCj3=9n|3=F@3LJcn%7)pVryh>nTu$sZZAYL$MSD+10f-TA0
z-33Sk!B6Mi^+1ZVz$3C4NPB>>+sSM@pz;4aT^vI)?!BF{-%lh^<k<er4^<gv_p&Y7
z5a6Zg64$`Q)H(Nkf>LYeh0KS$J$%{Sl9E*uS9%z*I94rI`KObn_UZY#U7OS2$#Q(w
zPES8ybKmy+9n173)28k24gJfUFlnAg)C3dl%#cfa|2)s1w9ot2q%DbQ@w3b-JS{fx
zyfL=0P0%#IyW+?11JAh*t>464GF!-=d5*;q@i~m2S01%zuDh<V?}50%bgvq5i?xA&
zj{4Yi=-&JA_UHePoikc_*SLtpZ-{8Wmc4qydLREwE?Y!Ty_k7(in)h+L9SI}g=ZCq
zO<!VyV&jin^F)mdCSN$P#{7WCgIg6Z+>DFoN-;Fst>#+D(^J(PrqIQx<t{1reYZl&
z1B-=?^7j}PN?8OwkkGw(IF4^Gqm$%~K7}nkYbDssgrshKVbjP~{ifpUCbnPu<;0mg
zw>{g+^Mo<pT}<Ee{oY63CvU%;+cEcr`+~>eQtKL(xX-K3b&dMVpY}~X=uJICaY}N+
z-8szK7kQtk%?mmo5P$5ph}y1{<OS*H_n!&3I}*hu%%;OsE!tAg8aF{)=db(Kg+4r2
zeJ1(_9bJCZFm=9|^{K9Z4mWSt1Yi1gb+OQ|Z7Q$R#O$Tz8p3<8yJRmiEo{#4y(98&
zO=ncptz8D2%O{2XzVm5wW-oK#q)v0+*PmwWh<&6#BSP7A`K?Pu-9NcMWNqH(cC2Fo
zFiEJExJHzuB$lLFB^RXvDF!10BLiInBV8l25JO8V0}#?SFt9Q(=$Rz597RKJeoAIq
zC2kFW&o7Y%YR~}LP+XR7m6TYVs#{u=$&i+rlWL`}uV0c|pr4zVo|&AjTM}d*V3zFb
UVt?;n0#FZwr>mdKI;Vst0H57OEdT%j

literal 0
HcmV?d00001

diff --git a/Samples/Sample.Android/Resources/drawable/magnify_plus.png b/Samples/Sample.Android/Resources/drawable/magnify_plus.png
new file mode 100644
index 0000000000000000000000000000000000000000..105954a634d66d0a7ec54001efea728c27bddb23
GIT binary patch
literal 824
zcmeAS@N?(olHy`uVBq!ia0vp^1|ZDA1|-9oezpTCmUKs7M+SzC{oH>NS%G}U;vjb?
zhIQv;UIIA^$sR$z3=CCj3=9n|3=F@3LJcn%7)pVryh>nTu$sZZAYL$MSD+10f-TA0
z-33Sk!B6Mi^+1ZVz$3C4NPB>>+sSM@pz%LFT^vI)?!BF{+fOu5r0sv{Bku)f>O#q@
zr#W%#V_<a?vc7-Ng-dwj<U{3+v-miU9P46P<70A6dat0cefLduOP*@KZ)f)LwER3}
zS$*x_|E=e4O`pidw$A+8H`W6xwiC7}Wd>fFv*h->=lYZOdEc74B{xm}msy3M#Rrie
z9v12cgwuD0e=KkKuG@0mlI2)!XFNllOUL{IE*m}FI!Oy}g}OuX2`i`kF#KS=@W)H9
zGtb5HS^hn@ecx8#aPAn}HK)rrFESj+I`@WMf2tr`U+@dr%6Ya^O3b~>&K2|Tn1A?y
z7vsm1&pt^;Xk;W9njPRhzd3qeW185OER){PU%fBK<bDWE&@;>6-XyW0bjmxI_pElz
z_qn8gOg(%c{QiL(wF?seowww9bCfOjU>+ayZC2hlD*Z3|gw$F4gxpmuF2t^An5p<O
zblnvHkLS)#l?!h@+#`B}-7R*@)sJk2Gb`0znjFYEkrkYN`pm!7lXbp#gsz$znASIL
zeZw}V(|yU#E9M`!wR9R@HQk{7`vCX!N_lBjABhcIGTQ~}SZt1)>TF)WYOYU7RQt-j
zpvnH-=ApGwGApxw`L8PbEbCeQb*WIA*)M71)A79$4b%62Ka!ASP}nKq6C<{6ZKsO+
zt&kZvmo51!>0I}Htzk!-*PeIL;XR$JRqIY2VN>;6#mpQ&<Nxlu9M`Fn-beydgKCLu
zL`h0wNvc(HQ7VvPFfuSQ&^0j9H8Kk^w6rp?urjsKHZZU<Fz7vA<cXpoH$NpatrE9}
zKeJAK1!~X$*-%`TZk3c+oT^(|l*y2mnUiXzudiQ{TcDqtn4X!Oty_{)<O`H`5kGdx
Q38;s`)78&qol`;+0B;XOr~m)}

literal 0
HcmV?d00001

diff --git a/Samples/Sample.Android/Resources/drawable/scanborder.xml b/Samples/Sample.Android/Resources/drawable/scanborder.xml
new file mode 100644
index 000000000..d436826aa
--- /dev/null
+++ b/Samples/Sample.Android/Resources/drawable/scanborder.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">    
+    <stroke android:width="3dp" android:color="#a83232" />    
+</shape>
\ No newline at end of file
diff --git a/Samples/Sample.Android/Resources/layout/Main.axml b/Samples/Sample.Android/Resources/layout/Main.axml
index 48e17ac52..7ad86e5c3 100644
--- a/Samples/Sample.Android/Resources/layout/Main.axml
+++ b/Samples/Sample.Android/Resources/layout/Main.axml
@@ -3,7 +3,7 @@
     android:orientation="vertical"
     android:layout_width="fill_parent"
     android:layout_height="fill_parent"
-    android:weightSum="5">
+    android:weightSum="7">
     <Button
         android:text="Scan with Default Overlay"
         android:layout_width="fill_parent"
@@ -22,16 +22,28 @@
         android:layout_height="wrap_content"
         android:text="Scan with Custom Overlay"
         android:layout_weight="1" />
+    <Button
+        android:id="@+id/buttonScanCustomAreaView"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:text="Scan with Custom Area Overlay"
+        android:layout_weight="1" />
     <Button
         android:text="Fragment Scanner"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:id="@+id/buttonFragment"
         android:layout_weight="1" />
+        <Button
+        android:text="Fragment Scanner Custom Area Overlay"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:id="@+id/buttonFragmentCustomArea"
+        android:layout_weight="1" />
     <Button
         android:text="Barcode Generator"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:id="@+id/buttonGenerate"
         android:layout_weight="1" />
-</LinearLayout>
\ No newline at end of file
+</LinearLayout>
diff --git a/Samples/Sample.Android/Resources/layout/ZxingOverlayCustomScanArea.xml b/Samples/Sample.Android/Resources/layout/ZxingOverlayCustomScanArea.xml
new file mode 100644
index 000000000..ac9cda759
--- /dev/null
+++ b/Samples/Sample.Android/Resources/layout/ZxingOverlayCustomScanArea.xml
@@ -0,0 +1,119 @@
+<androidx.constraintlayout.widget.ConstraintLayout
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        xmlns:app="http://schemas.android.com/apk/res-auto"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+
+  <LinearLayout
+  android:id="@+id/linearLayoutScanToolbar"
+  app:layout_constraintTop_toTopOf="parent"
+  app:layout_constraintStart_toStartOf="parent"
+  android:layout_width="match_parent"
+  android:layout_height="70dp"
+  android:visibility="visible"
+  android:orientation="horizontal"
+  android:background="@color/colorPrimaryDark">
+    <Button
+        android:layout_width="50dp"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center_vertical"
+        android:layout_marginLeft="8dp"
+        android:id="@+id/buttonSquareScanView"
+        android:text="SQ"
+        android:background="@color/colorAccent"
+        android:textColor="@android:color/white"/>
+    <Button
+        android:layout_width="50dp"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center_vertical"
+        android:layout_marginLeft="8dp"
+        android:id="@+id/buttonSquareScanRectangle"
+        android:text="REC"
+        android:background="@color/colorAccent"
+        android:textColor="@android:color/white"/>
+    <ToggleButton
+        android:id="@+id/toggleButtonScanViewLocation"
+        android:layout_gravity="center_vertical"
+        android:layout_marginLeft="8dp"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textOn="FULL WIDTH"
+        android:textOff="CENTER"/>
+    <ImageButton
+        android:id="@+id/buttonIncrease"
+        android:layout_marginLeft="20dp"
+        android:layout_width="30dp"
+        android:layout_height="30dp"
+        android:layout_gravity="center_vertical"
+        android:background="@drawable/magnify_plus"/>
+    <ImageButton
+        android:layout_marginLeft="20dp"
+        android:id="@+id/buttonDecrease"
+        android:layout_width="30dp"
+        android:layout_height="30dp"
+        android:layout_gravity="center_vertical"
+        android:background="@drawable/magnify_minus"/>
+  </LinearLayout>
+  <Button
+          app:layout_constraintTop_toBottomOf="@+id/linearLayoutScanToolbar"
+          app:layout_constraintStart_toStartOf="parent"
+          android:layout_width="wrap_content"
+          android:layout_height="wrap_content"
+          android:paddingHorizontal="8dp"
+          android:id="@+id/buttonRandom"
+          android:text="Random Position"
+          android:background="@color/colorAccent"
+          android:textColor="@android:color/white"/>
+  <androidx.constraintlayout.widget.ConstraintLayout
+      android:id="@+id/layoutScanViews"
+      app:layout_constraintTop_toBottomOf="@+id/buttonRandom"
+      app:layout_constraintStart_toStartOf="parent"
+      app:layout_constraintEnd_toEndOf="parent"
+      app:layout_constraintBottom_toBottomOf="parent"
+      android:layout_width="0dp"
+      android:layout_height="0dp">
+    <FrameLayout
+        android:id="@+id/viewTop"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintBottom_toTopOf="@id/scanView"
+        app:layout_constraintTop_toTopOf="parent"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:background="@color/transparentGrey"/>
+    <FrameLayout
+        android:id="@+id/viewLeft"
+        app:layout_constraintTop_toBottomOf="@id/viewTop"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toStartOf="@id/scanView"
+        app:layout_constraintBottom_toTopOf="@+id/viewBottom"
+        android:layout_width="0dp"
+        android:layout_height="0dp"
+        android:background="@color/transparentGrey"/>
+    <FrameLayout
+        android:id="@+id/scanView"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        android:layout_height="120dp"
+        android:layout_width="match_parent"
+        android:background="@drawable/scanborder">
+    </FrameLayout>
+    <FrameLayout
+        android:id="@+id/viewRight"
+        app:layout_constraintTop_toBottomOf="@id/viewTop"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toEndOf="@id/scanView"
+        app:layout_constraintBottom_toTopOf="@+id/viewBottom"
+        android:layout_width="0dp"
+        android:layout_height="0dp"
+        android:background="@color/transparentGrey"/>
+    <FrameLayout
+        android:id="@+id/viewBottom"
+        app:layout_constraintTop_toBottomOf="@id/scanView"
+        app:layout_constraintBottom_toBottomOf="parent"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:background="@color/transparentGrey"/>
+  </androidx.constraintlayout.widget.ConstraintLayout>
+</androidx.constraintlayout.widget.ConstraintLayout>
\ No newline at end of file
diff --git a/Samples/Sample.Android/Resources/values/colors.xml b/Samples/Sample.Android/Resources/values/colors.xml
new file mode 100644
index 000000000..e9ba816aa
--- /dev/null
+++ b/Samples/Sample.Android/Resources/values/colors.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#2c3e50</color>
+    <color name="colorPrimaryDark">#1B3147</color>
+    <color name="colorAccent">#3498db</color>
+    <color name="transparentGrey">#80777777</color>
+</resources>
diff --git a/Samples/Sample.Android/Sample.Android.csproj b/Samples/Sample.Android/Sample.Android.csproj
index 95d4f58b1..01e34b102 100644
--- a/Samples/Sample.Android/Sample.Android.csproj
+++ b/Samples/Sample.Android/Sample.Android.csproj
@@ -55,6 +55,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="FragmentActivityCustomScanArea.cs" />
     <Compile Include="Resources\Resource.designer.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="MainActivity.cs" />
@@ -84,7 +85,7 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <Folder Include="Resources\drawable\" />
+    <AndroidResource Include="Resources\values\colors.xml" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
   <ItemGroup>
@@ -93,8 +94,23 @@
     <PackageReference Include="Xamarin.AndroidX.Browser">
       <Version>1.0.0</Version>
     </PackageReference>
+    <PackageReference Include="Xamarin.AndroidX.ConstraintLayout">
+      <Version>1.1.3</Version>
+    </PackageReference>
     <PackageReference Include="Xamarin.Essentials">
       <Version>1.5.1</Version>
     </PackageReference>
   </ItemGroup>
+  <ItemGroup>
+    <AndroidResource Include="Resources\layout\ZxingOverlayCustomScanArea.xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <AndroidResource Include="Resources\drawable\magnify_minus.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <AndroidResource Include="Resources\drawable\magnify_plus.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <AndroidResource Include="Resources\drawable\scanborder.xml" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/ZXing.Net.Mobile/Android/CameraAccess/CameraAnalyzer.android.cs b/ZXing.Net.Mobile/Android/CameraAccess/CameraAnalyzer.android.cs
index 6d4f5c2be..0f1c5cff5 100644
--- a/ZXing.Net.Mobile/Android/CameraAccess/CameraAnalyzer.android.cs
+++ b/ZXing.Net.Mobile/Android/CameraAccess/CameraAnalyzer.android.cs
@@ -1,8 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
+using Android.Graphics;
 using Android.Views;
 using ApxLabs.FastAndroidCamera;
+using Xamarin.Essentials;
 
 namespace ZXing.Mobile.CameraAccess
 {
@@ -10,17 +11,43 @@ public class CameraAnalyzer
 	{
 		readonly CameraController cameraController;
 		readonly CameraEventsListener cameraEventListener;
+		readonly ZXingSurfaceView surfaceView;
 		Task processingTask;
 		DateTime lastPreviewAnalysis = DateTime.UtcNow;
 		bool wasScanned;
-		IScannerSessionHost scannerHost;
+		IScannerSessionHost scannerHost;        
+
+		//used for decoding
+		//updated only when the device is rotated or the CustomOverlayScanAreaView (if it is used) is changed
+		int widthCamera;
+		int heightCamera;
+		int widthScanAreaScaled;
+		int heightScanAreaScaled;
+		int offsetScanAreaLeftPixelsScaled;
+		int offsetScanAreaTopPixelsScaled;
+		int? lastDecodedCameraDisplayRotationDegree = null;
+		bool needRecalculateDecodingVariables = false;
+
+		enum Dimension
+		{
+			Width,
+			Height
+		};
 
 		public CameraAnalyzer(SurfaceView surfaceView, IScannerSessionHost scannerHost)
 		{
+			if (surfaceView is ZXingSurfaceView)
+                this.surfaceView = surfaceView as ZXingSurfaceView;
+
 			this.scannerHost = scannerHost;
 			cameraEventListener = new CameraEventsListener();
 			cameraController = new CameraController(surfaceView, cameraEventListener, scannerHost);
 			Torch = new Torch(cameraController, surfaceView.Context);
+			lastDecodedCameraDisplayRotationDegree = null;
+			if (this.surfaceView?.CustomScanArea != null)
+			{
+                this.surfaceView.CustomOverlay.LayoutChange += CustomOverlayScanAreaView_LayoutChange;
+			}
 		}
 
 		public Action<Result> BarcodeFound;
@@ -79,6 +106,11 @@ bool CanAnalyzeFrame
 
 				return true;
 			}
+		}        
+
+        void CustomOverlayScanAreaView_LayoutChange(object sender, View.LayoutChangeEventArgs e)
+		{
+			needRecalculateDecodingVariables = true;
 		}
 
 		void HandleOnPreviewFrameReady(object sender, FastJavaByteArray fastArray)
@@ -106,48 +138,205 @@ void HandleOnPreviewFrameReady(object sender, FastJavaByteArray fastArray)
 			}, TaskContinuationOptions.OnlyOnFaulted);
 		}
 
-		void DecodeFrame(FastJavaByteArray fastArray)
+		void SetCameraWidthHeightVariables()
 		{
 			var cameraParameters = cameraController.Camera.GetParameters();
-			var width = cameraParameters.PreviewSize.Width;
-			var height = cameraParameters.PreviewSize.Height;
 
-			var barcodeReader = scannerHost.ScanningOptions.BuildBarcodeReader();
+			if (DeviceDisplay.MainDisplayInfo.Orientation == DisplayOrientation.Portrait)
+			{
+				//the Android.Hardware.Camera API thinks that portrait is rotated
+				widthCamera = cameraParameters.PreviewSize.Height;
+				heightCamera = cameraParameters.PreviewSize.Width;
+			}
+			else
+			{
+				widthCamera = cameraParameters.PreviewSize.Width;
+				heightCamera = cameraParameters.PreviewSize.Height;
+			}
+		}
 
-			var rotate = false;
-			var newWidth = width;
-			var newHeight = height;
+		void SetDecodeVariablesForWholeScreen()
+		{
+			SetCameraWidthHeightVariables();
+			offsetScanAreaLeftPixelsScaled = 0;
+			offsetScanAreaTopPixelsScaled = 0;
+			heightScanAreaScaled = heightCamera;
+			widthScanAreaScaled = widthCamera;
+		}
 
-			// use last value for performance gain
-			var cDegrees = cameraController.LastCameraDisplayOrientationDegree;
+		//thank you so much Dr.Math for providing this formula
+		//http://mathforum.org/library/drmath/view/60433.html
+		int ScaleSurfaceViewToPreviewSize(int value, Rect surfaceView, Dimension dim)
+		{
+			double surfaceA = 0;
+			double surfaceB = 0;
+			double previewA = 0;
+			double previewB = 0;
 
-			if (cDegrees == 90 || cDegrees == 270)
+			switch (dim)
 			{
-				rotate = true;
-				newWidth = height;
-				newHeight = width;
+				case Dimension.Height:
+					surfaceA = 0;
+					surfaceB = surfaceView.Bottom;
+					previewA = 0;
+					previewB = heightCamera;
+					break;
+				case Dimension.Width:
+					surfaceA = 0;
+					surfaceB = surfaceView.Right;
+					previewA = 0;
+					previewB = widthCamera;
+					break;
 			}
 
-			ZXing.Result result = null;
+			var previewDiff = previewB - previewA;
+			var surfaceDiff = surfaceB - surfaceA;
+			var prevToSurfaceDiffRatio = previewDiff / surfaceDiff;
+			var surfaceLowDiff = value - surfaceA;
+
+			return (int)(previewA + (surfaceLowDiff * prevToSurfaceDiffRatio));
+		}
+
+		//thank you so much Dr.Math for providing this formula
+		//http://mathforum.org/library/drmath/view/60433.html
+		int ScaleSurfaceViewToPreviewLocation(int value, Rect surfaceView, Dimension dim)
+		{
+			double surfaceA = 0;
+			double surfaceB = 0;
+			double previewA = 0;
+			double previewB = 0;
+
+			switch (dim)
+			{
+				case Dimension.Height:
+					surfaceA = surfaceView.Top;
+					surfaceB = surfaceView.Bottom;
+					previewA = 0;
+					previewB = heightCamera;
+					break;
+				case Dimension.Width:
+					surfaceA = surfaceView.Left;
+					surfaceB = surfaceView.Right;
+					previewA = 0;
+					previewB = widthCamera;
+					break;
+			}
+
+			var previewDiff = previewB - previewA;
+			var surfaceDiff = surfaceB - surfaceA;
+			var prevToSurfaceDiffRatio = previewDiff / surfaceDiff;
+			var surfaceLowDiff = value - surfaceA;
+
+			return (int)(previewA + (surfaceLowDiff * prevToSurfaceDiffRatio));
+		}
+
+		void SetDecodeVariablesForCustomScanArea()
+		{
+			SetCameraWidthHeightVariables();
+			var rectangleScanArea = new Rect();
+			surfaceView.CustomScanArea?.GetGlobalVisibleRect(rectangleScanArea);
+			var originalWidth = rectangleScanArea.Right - rectangleScanArea.Left;
+			var originalHeight = rectangleScanArea.Bottom - rectangleScanArea.Top;
+
+			var rectangleSurfaceView = new Rect();
+			surfaceView.GetGlobalVisibleRect(rectangleSurfaceView);
+
+			//calculate the width and heigh of the scan area converting from the surface view resolution to the preview resolution
+			widthScanAreaScaled = ScaleSurfaceViewToPreviewSize(originalWidth, rectangleSurfaceView, Dimension.Width);
+			heightScanAreaScaled = ScaleSurfaceViewToPreviewSize(originalHeight, rectangleSurfaceView, Dimension.Height);
+
+			//calculate the position of the scan area converting from the surface view resolution to the preview resolution
+			var scanAreaTop = ScaleSurfaceViewToPreviewLocation(rectangleScanArea.Top, rectangleSurfaceView, Dimension.Height);
+			var scanAreaLeft = ScaleSurfaceViewToPreviewLocation(rectangleScanArea.Left, rectangleSurfaceView, Dimension.Width);
+			var scanAreaRight = ScaleSurfaceViewToPreviewLocation(rectangleScanArea.Right, rectangleSurfaceView, Dimension.Width);
+			var scanAreaBottom = ScaleSurfaceViewToPreviewLocation(rectangleScanArea.Bottom, rectangleSurfaceView, Dimension.Height);
+
+			//depending on the rotation angle of the camera the perspective of "Left" and "Top" is different
+			//some of the calculations are different than you may expect.  Rotation0 for example using a Right offset for Left.
+			//I believe some of them are backwards due to the camera preview rotation needing correction (SetCameraDisplayOrientation in CameraController.cs)           
+			//or MUCH more likely the Android.Hardware.Camera API is from the Stranger Things upsidedown universe where the Demogorgon lives
+			if (DeviceDisplay.MainDisplayInfo.Rotation == DisplayRotation.Rotation0)
+			{
+				offsetScanAreaLeftPixelsScaled = widthCamera - scanAreaRight;
+				offsetScanAreaTopPixelsScaled = scanAreaTop;
+			}
+			else if (DeviceDisplay.MainDisplayInfo.Rotation == DisplayRotation.Rotation90)
+			{
+				offsetScanAreaLeftPixelsScaled = scanAreaLeft;
+				offsetScanAreaTopPixelsScaled = scanAreaTop;
+			}
+			else if (DeviceDisplay.MainDisplayInfo.Rotation == DisplayRotation.Rotation180)
+			{
+				//not sure about these.  Devices don't want to rotate upside down.  But they should be opposite from a 0 degree rotation.
+				offsetScanAreaLeftPixelsScaled = scanAreaLeft;
+				offsetScanAreaTopPixelsScaled = heightCamera - scanAreaBottom;
+			}
+			else if (DeviceDisplay.MainDisplayInfo.Rotation == DisplayRotation.Rotation270)
+			{
+				offsetScanAreaLeftPixelsScaled = widthCamera - scanAreaRight;
+				offsetScanAreaTopPixelsScaled = heightCamera - scanAreaBottom;
+			}
+			else
+			{
+				//something is wrong, just scan the whole available preview
+				SetDecodeVariablesForWholeScreen();
+			}
+		}
+
+		void DecodeFrame(FastJavaByteArray fastArray)
+		{
+			var rotate = DeviceDisplay.MainDisplayInfo.Orientation == DisplayOrientation.Portrait;
 			var start = PerformanceCounter.Start();
 
-			LuminanceSource fast = new FastJavaByteArrayYUVLuminanceSource(fastArray, width, height, 0, 0, width, height); // _area.Left, _area.Top, _area.Width, _area.Height);
+			//only calculate the variables needed for decoding if the camera is rotated or the CustomScanAreaView (if used) is changed
+			if (lastDecodedCameraDisplayRotationDegree != cameraController.CurrentCameraDisplayRotationDegree || needRecalculateDecodingVariables)
+			{
+				if (surfaceView != null && surfaceView.UsingCustomScanArea)
+					SetDecodeVariablesForCustomScanArea();
+				else
+					SetDecodeVariablesForWholeScreen();
+
+				lastDecodedCameraDisplayRotationDegree = cameraController.CurrentCameraDisplayRotationDegree;
+				needRecalculateDecodingVariables = false;
+			}
+
+			var barcodeReader = scannerHost.ScanningOptions.BuildBarcodeReader();
+			LuminanceSource fast;
+
 			if (rotate)
-				fast = fast.rotateCounterClockwise();
+			{
+				//for decoding it is expected that the FastJavaByteArrayYUVLuminanceSource will be in landscape orientation
+				//if we are in portrait mode the array must be rotated
+				//also since we are in portrait mode and all dimensions are calculated from the perspective of the user they must be
+				//given to the constructor flipped
+				fast = new FastJavaByteArrayYUVLuminanceSource(fastArray, heightCamera, widthCamera,
+																			offsetScanAreaTopPixelsScaled,
+																			offsetScanAreaLeftPixelsScaled,
+																			heightScanAreaScaled,
+																			widthScanAreaScaled).rotateCounterClockwise();
+			}
+			else
+			{
+				//while in landscape mode the FastJavaByteArrayYUVLuminanceSource paramater names match up with the names of the calculated values
+				fast = new FastJavaByteArrayYUVLuminanceSource(fastArray, widthCamera, heightCamera,
+																			offsetScanAreaLeftPixelsScaled,
+																			offsetScanAreaTopPixelsScaled,
+																			widthScanAreaScaled,
+																			heightScanAreaScaled);
+			}
 
-			result = barcodeReader.Decode(fast);
 
+			var result = barcodeReader.Decode(fast);
 			fastArray.Dispose();
 			fastArray = null;
 
 			PerformanceCounter.Stop(start,
-				"Decode Time: {0} ms (width: " + width + ", height: " + height + ", degrees: " + cDegrees + ", rotate: " +
-				rotate + ")");
+					"Decode Time: {0} ms (width: " + widthCamera + ", height: " + heightCamera + ", degrees: " + lastDecodedCameraDisplayRotationDegree + ", rotate: " +
+					rotate + ")");
 
 			if (result != null)
 			{
 				Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Barcode Found");
-
 				wasScanned = true;
 				BarcodeFound?.Invoke(result);
 				return;
diff --git a/ZXing.Net.Mobile/Android/CameraAccess/CameraController.android.cs b/ZXing.Net.Mobile/Android/CameraAccess/CameraController.android.cs
index 484be6074..e1e4e49c4 100644
--- a/ZXing.Net.Mobile/Android/CameraAccess/CameraController.android.cs
+++ b/ZXing.Net.Mobile/Android/CameraAccess/CameraController.android.cs
@@ -8,6 +8,7 @@
 using Android.Runtime;
 using Android.Views;
 using ApxLabs.FastAndroidCamera;
+using Xamarin.Essentials;
 using Camera = Android.Hardware.Camera;
 
 namespace ZXing.Mobile.CameraAccess
@@ -32,7 +33,7 @@ public CameraController(SurfaceView surfaceView, CameraEventsListener cameraEven
 
 		public Camera Camera { get; private set; }
 
-		public int LastCameraDisplayOrientationDegree { get; private set; }
+        public int CurrentCameraDisplayRotationDegree { get; private set; }
 
 		public void RefreshCamera()
 		{
@@ -369,64 +370,62 @@ void AutoFocus(int x, int y, bool useCoordinates)
 			}
 		}
 
-		void SetCameraDisplayOrientation()
-		{
-			var degrees = GetCameraDisplayOrientation();
-			LastCameraDisplayOrientationDegree = degrees;
-
-			Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Changing Camera Orientation to: " + degrees);
-
-			try
-			{
-				Camera.SetDisplayOrientation(degrees);
-			}
-			catch (Exception ex)
-			{
-				Android.Util.Log.Error(MobileBarcodeScanner.TAG, ex.ToString());
-			}
-		}
-
-		int GetCameraDisplayOrientation()
-		{
-			int degrees;
-			var windowManager = context.GetSystemService(Context.WindowService).JavaCast<IWindowManager>();
-			var display = windowManager.DefaultDisplay;
-			var rotation = display.Rotation;
-
-			switch (rotation)
-			{
-				case SurfaceOrientation.Rotation0:
-					degrees = 0;
-					break;
-				case SurfaceOrientation.Rotation90:
-					degrees = 90;
-					break;
-				case SurfaceOrientation.Rotation180:
-					degrees = 180;
-					break;
-				case SurfaceOrientation.Rotation270:
-					degrees = 270;
-					break;
-				default:
-					throw new ArgumentOutOfRangeException();
-			}
-
-			var info = new Camera.CameraInfo();
-			Camera.GetCameraInfo(cameraId, info);
-
-			int correctedDegrees;
-			if (info.Facing == CameraFacing.Front)
-			{
-				correctedDegrees = (info.Orientation + degrees) % 360;
-				correctedDegrees = (360 - correctedDegrees) % 360; // compensate the mirror
-			}
-			else
-			{
-				// back-facing
-				correctedDegrees = (info.Orientation - degrees + 360) % 360;
-			}
-
-			return correctedDegrees;
-		}
-	}
-}
\ No newline at end of file
+        void SetCameraDisplayOrientation()
+        {
+            int currentDegrees;
+            int correctedDegrees;
+            
+            currentDegrees = GetCurrentCameraDisplayDegrees();            
+            CurrentCameraDisplayRotationDegree = currentDegrees;            
+
+            correctedDegrees = GetCorrectedCameraDisplayDegrees(currentDegrees);
+            Android.Util.Log.Debug(MobileBarcodeScanner.TAG, "Changing Camera Orientation to: " + correctedDegrees);
+
+            try
+            {
+                Camera.SetDisplayOrientation(correctedDegrees);
+            }
+            catch (Exception ex)
+            {
+                Android.Util.Log.Error(MobileBarcodeScanner.TAG, ex.ToString());
+            }
+        }
+
+        int GetCorrectedCameraDisplayDegrees(int degrees)
+        {
+            var info = new Camera.CameraInfo();
+            Camera.GetCameraInfo(cameraId, info);
+
+            int correctedDegrees;
+            if (info.Facing == CameraFacing.Front)
+            {
+                correctedDegrees = (info.Orientation + degrees) % 360;
+                correctedDegrees = (360 - correctedDegrees) % 360; // compensate the mirror
+            }
+            else
+            {
+                // back-facing
+                correctedDegrees = (info.Orientation - degrees + 360) % 360;
+            }
+
+            return correctedDegrees;
+        }
+
+        int GetCurrentCameraDisplayDegrees()
+        {            
+            switch (DeviceDisplay.MainDisplayInfo.Rotation)
+            {
+                case DisplayRotation.Rotation0:
+                    return 0;                    
+                case DisplayRotation.Rotation90:
+                    return 90;                    
+                case DisplayRotation.Rotation180:
+                    return 180;                    
+                case DisplayRotation.Rotation270:
+                    return 270;                    
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+    }
+}
diff --git a/ZXing.Net.Mobile/Android/MobileBarcodeScanner.android.cs b/ZXing.Net.Mobile/Android/MobileBarcodeScanner.android.cs
index 28a7f6af7..0f58c78fa 100644
--- a/ZXing.Net.Mobile/Android/MobileBarcodeScanner.android.cs
+++ b/ZXing.Net.Mobile/Android/MobileBarcodeScanner.android.cs
@@ -21,6 +21,7 @@ public static void Uninitialize(Android.App.Application app)
 		}
 
 		public Android.Views.View CustomOverlay { get; set; }
+		public Android.Views.View CustomOverlayScanAreaView { get; set; }
 
 		bool torch = false;
 
@@ -37,6 +38,7 @@ public void ScanContinuously(Context context, MobileBarcodeScanningOptions optio
 
 			scanIntent.AddFlags(ActivityFlags.NewTask);
 
+			ZxingActivity.CustomOverlayScanAreaView = this.CustomOverlayScanAreaView;
 			ZxingActivity.UseCustomOverlayView = this.UseCustomOverlay;
 			ZxingActivity.CustomOverlayView = this.CustomOverlay;
 			ZxingActivity.ScanningOptions = options;
@@ -65,7 +67,7 @@ public Task<Result> Scan(Context context, MobileBarcodeScanningOptions options)
 				var scanIntent = new Intent(ctx, typeof(ZxingActivity));
 
 				scanIntent.AddFlags(ActivityFlags.NewTask);
-
+				ZxingActivity.CustomOverlayScanAreaView = this.CustomOverlayScanAreaView;
 				ZxingActivity.UseCustomOverlayView = this.UseCustomOverlay;
 				ZxingActivity.CustomOverlayView = this.CustomOverlay;
 				ZxingActivity.ScanningOptions = options;
diff --git a/ZXing.Net.Mobile/Android/ZXingScannerFragment.android.cs b/ZXing.Net.Mobile/Android/ZXingScannerFragment.android.cs
index 5d5895d5c..390404dae 100644
--- a/ZXing.Net.Mobile/Android/ZXingScannerFragment.android.cs
+++ b/ZXing.Net.Mobile/Android/ZXingScannerFragment.android.cs
@@ -11,11 +11,18 @@
 namespace ZXing.Mobile
 {
 	public class ZXingScannerFragment : Fragment, IZXingScanner<View>, IScannerView
-	{
+	{		
 		public ZXingScannerFragment()
-		{
-			UseCustomOverlayView = false;
-		}
+        {
+
+        }
+
+        public ZXingScannerFragment(View customOverlayView = null, bool useCustomOverlay = true, View scanAreaView = null)
+        {
+			UseCustomOverlayView = useCustomOverlay;
+            CustomOverlayView = customOverlayView;
+            CustomOverlayScanAreaView = scanAreaView;
+        }
 
 		FrameLayout frame;
 
@@ -27,7 +34,7 @@ public override View OnCreateView(LayoutInflater layoutInflater, ViewGroup viewG
 
 			try
 			{
-				scanner = new ZXingSurfaceView(Activity, ScanningOptions);
+				scanner = new ZXingSurfaceView(Activity, ScanningOptions, CustomOverlayView, CustomOverlayScanAreaView);
 
 				frame.AddView(scanner, layoutParams);
 
@@ -96,14 +103,15 @@ LinearLayout.LayoutParams GetChildLayoutParams()
 			return layoutParams;
 		}
 
-		public View CustomOverlayView { get; set; }
+		public View CustomOverlayView { get; set; }		
+		public View CustomOverlayScanAreaView { get; set; }
 		public bool UseCustomOverlayView { get; set; }
 		public MobileBarcodeScanningOptions ScanningOptions { get; set; }
 		public string TopText { get; set; }
 		public string BottomText { get; set; }
 
 		ZXingSurfaceView scanner;
-		ZxingOverlayView zxingOverlay;
+		ZxingOverlayView zxingOverlay;		
 
 		public void Torch(bool on)
 			=> scanner?.Torch(on);
diff --git a/ZXing.Net.Mobile/Android/ZXingSurfaceView.android.cs b/ZXing.Net.Mobile/Android/ZXingSurfaceView.android.cs
index 0fe0c87f1..3a2831f2e 100644
--- a/ZXing.Net.Mobile/Android/ZXingSurfaceView.android.cs
+++ b/ZXing.Net.Mobile/Android/ZXingSurfaceView.android.cs
@@ -10,6 +10,19 @@ namespace ZXing.Mobile
 {
 	public class ZXingSurfaceView : SurfaceView, ISurfaceHolderCallback, IScannerView, IScannerSessionHost
 	{
+		public View CustomOverlay { get; private set; }
+		public View CustomScanArea { get; private set; }
+		public bool UsingCustomScanArea { get { return CustomOverlay != null; } }
+
+		public ZXingSurfaceView(Context context, MobileBarcodeScanningOptions options = null, View customOverlay = null, View customScanArea = null)
+			: base(context)
+		{
+			ScanningOptions = options ?? new MobileBarcodeScanningOptions();
+			CustomOverlay = customOverlay;
+			CustomScanArea = customScanArea;
+			Init();
+		}
+
 		public ZXingSurfaceView(Context context, MobileBarcodeScanningOptions options)
 			: base(context)
 		{
diff --git a/ZXing.Net.Mobile/Android/ZxingActivity.android.cs b/ZXing.Net.Mobile/Android/ZxingActivity.android.cs
index 23b54bc75..5903f64a7 100644
--- a/ZXing.Net.Mobile/Android/ZxingActivity.android.cs
+++ b/ZXing.Net.Mobile/Android/ZxingActivity.android.cs
@@ -59,6 +59,8 @@ public static void RequestResumeAnalysis()
 			=> ResumeAnalysisHandler?.Invoke();
 
 		public static View CustomOverlayView { get; set; }
+		
+		public static View CustomOverlayScanAreaView { get; set; }
 
 		public static bool UseCustomOverlayView { get; set; }
 
@@ -86,8 +88,16 @@ protected override void OnCreate(Bundle bundle)
 
 			SetContentView(ZXing.Net.Mobile.Resource.Layout.zxingscanneractivitylayout);
 
+            //since these are static the views may still exist if the MobileBarcodeScanner object is re-used
+            if (!UseCustomOverlayView)
+            {
+                CustomOverlayView = null;
+                CustomOverlayScanAreaView = null;
+            }
+
 			scannerFragment = new ZXingScannerFragment();
 			scannerFragment.CustomOverlayView = CustomOverlayView;
+			scannerFragment.CustomOverlayScanAreaView = CustomOverlayScanAreaView;
 			scannerFragment.UseCustomOverlayView = UseCustomOverlayView;
 			scannerFragment.TopText = TopText;
 			scannerFragment.BottomText = BottomText;
@@ -158,4 +168,4 @@ public override bool OnKeyDown(Keycode keyCode, KeyEvent e)
 			return base.OnKeyDown(keyCode, e);
 		}
 	}
-}
\ No newline at end of file
+}