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 000000000..103b5a0ef
Binary files /dev/null and b/Samples/Sample.Android/Resources/drawable/magnify_minus.png differ
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 000000000..105954a63
Binary files /dev/null and b/Samples/Sample.Android/Resources/drawable/magnify_plus.png differ
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
+}