From 8239450a2bc45e2e2f73c6459afa779347e3e09a Mon Sep 17 00:00:00 2001
From: Hector Alonso <hjam27@outlook.es>
Date: Mon, 10 Apr 2023 00:44:18 +0200
Subject: [PATCH] Added recrod video/audio. Changed Android Handler

---
 Camera.MAUI.Test/Camera.MAUI.Test.csproj      |   5 +
 Camera.MAUI.Test/FullScreenPage.xaml.cs       |   2 +
 Camera.MAUI.Test/MVVM/CameraViewModel.cs      | 183 ++++
 Camera.MAUI.Test/MVVM/MVVMPage.xaml           |  64 ++
 Camera.MAUI.Test/MVVM/MVVMPage.xaml.cs        |   9 +
 Camera.MAUI.Test/MainPage.xaml                |   1 +
 Camera.MAUI.Test/MainPage.xaml.cs             |   5 +
 Camera.MAUI.Test/MauiProgram.cs               |   7 +-
 .../Platforms/Android/AndroidManifest.xml     |   2 +
 Camera.MAUI.Test/Platforms/iOS/Info.plist     |   2 +
 Camera.MAUI.Test/SizedPage.xaml               |  23 +-
 Camera.MAUI.Test/SizedPage.xaml.cs            |  53 +-
 Camera.MAUI/Apple/MauiCameraView.cs           | 147 ++-
 Camera.MAUI/Camera.MAUI.csproj                |   9 +-
 Camera.MAUI/CameraResult.cs                   |   3 +-
 Camera.MAUI/CameraView.cs                     | 222 +++-
 Camera.MAUI/CameraViewHandler.cs              |  32 +-
 Camera.MAUI/MicrophoneInfo.cs                 |  11 +
 .../Platforms/Android/MauiCameraView.cs       | 642 +++++++-----
 .../Platforms/Windows/MauiCameraView.cs       | 120 ++-
 MauiCameraView.backup                         | 980 ++++++++++++++++++
 Readme.md                                     |  63 +-
 22 files changed, 2205 insertions(+), 380 deletions(-)
 create mode 100644 Camera.MAUI.Test/MVVM/CameraViewModel.cs
 create mode 100644 Camera.MAUI.Test/MVVM/MVVMPage.xaml
 create mode 100644 Camera.MAUI.Test/MVVM/MVVMPage.xaml.cs
 create mode 100644 Camera.MAUI/MicrophoneInfo.cs
 create mode 100644 MauiCameraView.backup

diff --git a/Camera.MAUI.Test/Camera.MAUI.Test.csproj b/Camera.MAUI.Test/Camera.MAUI.Test.csproj
index 6451e30..a656ee8 100644
--- a/Camera.MAUI.Test/Camera.MAUI.Test.csproj
+++ b/Camera.MAUI.Test/Camera.MAUI.Test.csproj
@@ -53,6 +53,8 @@
 	</ItemGroup>
 
 	<ItemGroup>
+		<PackageReference Include="CommunityToolkit.Maui" Version="5.0.0" />
+		<PackageReference Include="CommunityToolkit.Maui.MediaElement" Version="1.0.2" />
 		<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="7.0.0" />
 	</ItemGroup>
 
@@ -67,6 +69,9 @@
 	  <MauiXaml Update="FullScreenPage.xaml">
 	    <Generator>MSBuild:Compile</Generator>
 	  </MauiXaml>
+	  <MauiXaml Update="MVVM\MVVMPage.xaml">
+	    <Generator>MSBuild:Compile</Generator>
+	  </MauiXaml>
 	  <MauiXaml Update="SizedPage.xaml">
 	    <Generator>MSBuild:Compile</Generator>
 	  </MauiXaml>
diff --git a/Camera.MAUI.Test/FullScreenPage.xaml.cs b/Camera.MAUI.Test/FullScreenPage.xaml.cs
index 0094673..8a0d312 100644
--- a/Camera.MAUI.Test/FullScreenPage.xaml.cs
+++ b/Camera.MAUI.Test/FullScreenPage.xaml.cs
@@ -13,6 +13,7 @@ private void CameraView_CamerasLoaded(object sender, EventArgs e)
         if (cameraView.Cameras.Count > 0)
         {
             cameraView.Camera = cameraView.Cameras.First();
+            /*
             MainThread.BeginInvokeOnMainThread(async () =>
             {
                 if (await cameraView.StartCameraAsync() == CameraResult.Success)
@@ -21,6 +22,7 @@ private void CameraView_CamerasLoaded(object sender, EventArgs e)
                     playing = true;
                 }
             });
+            */
         }
     }
     private async void Button_Clicked(object sender, EventArgs e)
diff --git a/Camera.MAUI.Test/MVVM/CameraViewModel.cs b/Camera.MAUI.Test/MVVM/CameraViewModel.cs
new file mode 100644
index 0000000..8b04dce
--- /dev/null
+++ b/Camera.MAUI.Test/MVVM/CameraViewModel.cs
@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ZXing;
+using System.Windows.Markup;
+using System.Collections.Specialized;
+using Camera.MAUI.ZXingHelper;
+using CommunityToolkit.Maui.Views;
+
+namespace Camera.MAUI.Test;
+
+public class CameraViewModel : INotifyPropertyChanged
+{
+    private CameraInfo camera = null;
+    public CameraInfo Camera 
+    {
+        get => camera;
+        set
+        {
+            camera = value;
+            OnPropertyChanged(nameof(Camera));
+            AutoStartPreview = false;
+            OnPropertyChanged(nameof(AutoStartPreview));
+            AutoStartPreview = true;
+            OnPropertyChanged(nameof(AutoStartPreview));
+        }
+    }
+    private ObservableCollection<CameraInfo> cameras = new();
+    public ObservableCollection<CameraInfo> Cameras
+    {
+        get => cameras;
+        set
+        {
+            cameras = value;
+            OnPropertyChanged(nameof(Cameras));
+        }
+    }
+    public int NumCameras
+    {
+        set
+        {
+            if (value > 0)
+                Camera = Cameras.First();
+        }
+    }
+    private MicrophoneInfo micro = null;
+    public MicrophoneInfo Microphone
+    {
+        get => micro;
+        set
+        {
+            micro = value;
+            OnPropertyChanged(nameof(Microphone));
+        }
+    }
+    private ObservableCollection<MicrophoneInfo> micros = new();
+    public ObservableCollection<MicrophoneInfo> Microphones
+    {
+        get => micros;
+        set
+        {
+            micros = value;
+            OnPropertyChanged(nameof(Microphones));
+        }
+    }
+    public int NumMicrophones
+    {
+        set
+        {
+            if (value > 0)
+                Microphone = Microphones.First();
+        }
+    }
+    public MediaSource VideoSource { get; set; }
+    public BarcodeDecodeOptions BarCodeOptions { get; set; }
+    public string BarcodeText { get; set; } = "No barcode detected";
+    public bool AutoStartPreview { get; set; } = false;
+    public bool AutoStartRecording { get; set; } = false;
+    private Result[] barCodeResults;
+    public Result[] BarCodeResults 
+    {
+        get => barCodeResults;
+        set
+        {
+            barCodeResults = value;
+            if (barCodeResults != null && barCodeResults.Length > 0)
+                BarcodeText = barCodeResults[0].Text;
+            else
+                BarcodeText = "No barcode detected";
+            OnPropertyChanged(nameof(BarcodeText));
+        }
+    }
+    private bool takeSnapshot = false;
+    public bool TakeSnapshot 
+    { 
+        get => takeSnapshot;
+        set
+        {
+            takeSnapshot = value;
+            OnPropertyChanged(nameof(TakeSnapshot));
+        } 
+    }
+    public float SnapshotSeconds { get; set; } = 0f;
+    public string Seconds
+    {
+        get => SnapshotSeconds.ToString();
+        set
+        {
+            if (float.TryParse(value, out float seconds))
+            {
+                SnapshotSeconds = seconds;
+                OnPropertyChanged(nameof(SnapshotSeconds));
+            }
+        }
+    }
+    public Command StartCamera { get; set; }
+    public Command StopCamera { get; set; }
+    public Command TakeSnapshotCmd { get; set; }
+    public string RecordingFile { get; set; }
+    public Command StartRecording { get; set; }
+    public Command StopRecording { get; set; }
+
+    public event PropertyChangedEventHandler PropertyChanged;
+
+    protected virtual void OnPropertyChanged(string propertyName)
+    {
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+    public CameraViewModel()
+    {
+        BarCodeOptions = new ZXingHelper.BarcodeDecodeOptions
+        {
+            AutoRotate = true,
+            PossibleFormats = { ZXing.BarcodeFormat.QR_CODE },
+            ReadMultipleCodes = false,
+            TryHarder = true,
+            TryInverted = true
+        };
+        OnPropertyChanged(nameof(BarCodeOptions));
+        StartCamera = new Command(() =>
+        {
+            AutoStartPreview = true;
+            OnPropertyChanged(nameof(AutoStartPreview));
+        });
+        StopCamera = new Command(() =>
+        {
+            AutoStartPreview = false;
+            OnPropertyChanged(nameof(AutoStartPreview));
+        });
+        TakeSnapshotCmd = new Command(() =>
+        {
+            TakeSnapshot = false;
+            TakeSnapshot = true;
+        });
+#if IOS
+        RecordingFile = Path.Combine(FileSystem.Current.CacheDirectory, "Video.mov");
+#else
+        RecordingFile = Path.Combine(FileSystem.Current.CacheDirectory, "Video.mp4");
+#endif
+        OnPropertyChanged(nameof(RecordingFile));
+        StartRecording = new Command(() =>
+        {
+            AutoStartRecording = true;
+            OnPropertyChanged(nameof(AutoStartRecording));
+        });
+        StopRecording = new Command(() =>
+        {
+            AutoStartRecording = false;
+            OnPropertyChanged(nameof(AutoStartRecording));
+            VideoSource = MediaSource.FromFile(RecordingFile);
+            OnPropertyChanged(nameof(VideoSource));
+        });
+        OnPropertyChanged(nameof(StartCamera));
+        OnPropertyChanged(nameof(StopCamera));
+        OnPropertyChanged(nameof(TakeSnapshotCmd));
+        OnPropertyChanged(nameof(StartRecording));
+        OnPropertyChanged(nameof(StopRecording));
+    }
+}
diff --git a/Camera.MAUI.Test/MVVM/MVVMPage.xaml b/Camera.MAUI.Test/MVVM/MVVMPage.xaml
new file mode 100644
index 0000000..453d222
--- /dev/null
+++ b/Camera.MAUI.Test/MVVM/MVVMPage.xaml
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             x:Class="Camera.MAUI.Test.MVVMPage"
+             xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit"
+             xmlns:local="clr-namespace:Camera.MAUI.Test"
+             xmlns:cv="clr-namespace:Camera.MAUI;assembly=Camera.MAUI"
+             Title="MVVMPage" Background="white">
+    <ContentPage.BindingContext>
+        <local:CameraViewModel />
+    </ContentPage.BindingContext>
+    <ScrollView>
+        <Grid>
+            <VerticalStackLayout HorizontalOptions="Center" VerticalOptions="Center">
+                <cv:CameraView x:Name="cameraView" WidthRequest="300" HeightRequest="200" BarCodeOptions="{Binding BarCodeOptions}" BarCodeResults="{Binding BarCodeResults, Mode=OneWayToSource}"
+                               Cameras="{Binding Cameras, Mode=OneWayToSource}" Camera="{Binding Camera}" AutoStartPreview="{Binding AutoStartPreview}" NumCamerasDetected="{Binding NumCameras, Mode=OneWayToSource}"
+                               AutoSnapShotAsImageSource="True" AutoSnapShotFormat="PNG" TakeAutoSnapShot="{Binding TakeSnapshot}" AutoSnapShotSeconds="{Binding SnapshotSeconds}"
+                               Microphones="{Binding Microphones, Mode=OneWayToSource}" Microphone="{Binding Microphone}" NumMicrophonesDetected="{Binding NumMicrophones, Mode=OneWayToSource}" 
+                               AutoRecordingFile="{Binding RecordingFile}" AutoStartRecording="{Binding AutoStartRecording}"/>
+                <HorizontalStackLayout HorizontalOptions="Center" Margin="5">
+                    <Label Text="Select a camera:" VerticalOptions="Center" BackgroundColor="White" TextColor="Black"/>
+                    <Picker VerticalOptions="Center" TextColor="Black" ItemsSource="{Binding Cameras}" SelectedItem="{Binding Camera,Mode=TwoWay}"/>
+                </HorizontalStackLayout>
+                <HorizontalStackLayout HorizontalOptions="Center" Margin="5">
+                    <Label Text="Select a microphone:" VerticalOptions="Center" BackgroundColor="White" TextColor="Black"/>
+                    <Picker  VerticalOptions="Center" TextColor="Black" ItemsSource="{Binding Microphones}" SelectedItem="{Binding Microphone,Mode=TwoWay}"/>
+                </HorizontalStackLayout>
+                <HorizontalStackLayout HorizontalOptions="Center">
+                    <Label Text="Mirrored" VerticalOptions="Center" TextColor="Black"/>
+                    <CheckBox BindingContext="{x:Reference cameraView}" VerticalOptions="Center" Color="Black" IsChecked="{Binding MirroredImage}"/>
+                    <Label Text="Torch" VerticalOptions="Center" TextColor="Black"/>
+                    <CheckBox BindingContext="{x:Reference cameraView}" VerticalOptions="Center" Color="Black" IsChecked="{Binding TorchEnabled}"/>
+                    <Label Text="QR Detec." VerticalOptions="Center" TextColor="Black"/>
+                    <CheckBox BindingContext="{x:Reference cameraView}" VerticalOptions="Center" Color="Black" IsChecked="{Binding BarCodeDetectionEnabled}"/>
+                </HorizontalStackLayout>
+                <HorizontalStackLayout HorizontalOptions="Center">
+                    <Label Text="AutoSnap freq: " VerticalOptions="Center" TextColor="Black"/>
+                    <Entry WidthRequest="20" Keyboard="Numeric" TextColor="Black" Text="{Binding Seconds, Mode=TwoWay}" />
+                    <Label Text="Take Autosnap" VerticalOptions="Center" TextColor="Black"/>
+                    <CheckBox VerticalOptions="Center" Color="Black" IsChecked="{Binding TakeSnapshot, Mode=OneWayToSource}"/>
+                    <Label Text="As ISource" VerticalOptions="Center" TextColor="Black"/>
+                    <CheckBox BindingContext="{x:Reference cameraView}" IsChecked="{Binding AutoSnapShotAsImageSource}" VerticalOptions="Center" Color="Black"/>
+                </HorizontalStackLayout>
+                <HorizontalStackLayout HorizontalOptions="Center" Margin="2" Spacing="2">
+                    <Label Text="Zoom" VerticalOptions="Center" TextColor="Black"/>
+                    <Stepper BindingContext="{x:Reference cameraView}" Minimum="{Binding MinZoomFactor}" Maximum="7" Increment="0.5" Value="{Binding ZoomFactor,Mode=TwoWay}" />
+                </HorizontalStackLayout>
+                <HorizontalStackLayout HorizontalOptions="Center" Margin="5">
+                    <Button Text="Start Camera" Command="{Binding StartCamera}" />
+                    <Button Text="Stop Camera" Command="{Binding StopCamera}" />
+                    <Button Text="Take Photo" Command="{Binding TakeSnapshotCmd}" />
+                </HorizontalStackLayout>
+                <HorizontalStackLayout HorizontalOptions="Center" Margin="5">
+                    <Button Text="Start Record" Command="{Binding StartRecording}" />
+                    <Button Text="Stop Record" Command="{Binding StopRecording}" />
+                </HorizontalStackLayout>
+                <Label Text="{Binding BarcodeText}" TextColor="Black" FontAttributes="Bold" HorizontalOptions="Center" />
+                <Image BindingContext="{x:Reference cameraView}" Source="{Binding SnapShot}" Aspect="AspectFit" WidthRequest="250" HeightRequest="100" HorizontalOptions="Center" />
+                <toolkit:MediaElement Source="{Binding VideoSource}" ShouldAutoPlay="False" ShouldShowPlaybackControls="True" HeightRequest="300" WidthRequest="200" />
+            </VerticalStackLayout>
+        </Grid>
+    </ScrollView>
+
+</ContentPage>
\ No newline at end of file
diff --git a/Camera.MAUI.Test/MVVM/MVVMPage.xaml.cs b/Camera.MAUI.Test/MVVM/MVVMPage.xaml.cs
new file mode 100644
index 0000000..ac1b73c
--- /dev/null
+++ b/Camera.MAUI.Test/MVVM/MVVMPage.xaml.cs
@@ -0,0 +1,9 @@
+namespace Camera.MAUI.Test;
+
+public partial class MVVMPage : ContentPage
+{
+	public MVVMPage()
+	{
+		InitializeComponent();
+	}
+}
\ No newline at end of file
diff --git a/Camera.MAUI.Test/MainPage.xaml b/Camera.MAUI.Test/MainPage.xaml
index ee08519..6b44831 100644
--- a/Camera.MAUI.Test/MainPage.xaml
+++ b/Camera.MAUI.Test/MainPage.xaml
@@ -7,6 +7,7 @@
     <ScrollView>
         <Grid>
             <VerticalStackLayout HorizontalOptions="Center" VerticalOptions="Center">
+                <Button HorizontalOptions="Center" Text="Go to MVVM Cam" Clicked="Button_Clicked_2" Margin="5"/>
                 <Button HorizontalOptions="Center" Text="Go to Parameters Cam" Clicked="Button_Clicked" Margin="5"/>
                 <Button HorizontalOptions="Center" Text="Go to Fullscreen Cam" Clicked="Button2_Clicked" Margin="5"/>
                 <Button HorizontalOptions="Center" Text="Go to Code generation" Clicked="Button_Clicked_1" Margin="5"/>
diff --git a/Camera.MAUI.Test/MainPage.xaml.cs b/Camera.MAUI.Test/MainPage.xaml.cs
index 86c351b..0c57ae8 100644
--- a/Camera.MAUI.Test/MainPage.xaml.cs
+++ b/Camera.MAUI.Test/MainPage.xaml.cs
@@ -20,4 +20,9 @@ private async void Button_Clicked_1(object sender, EventArgs e)
     {
         await Navigation.PushAsync(new BarcodeGenerationPage());
     }
+
+    private async void Button_Clicked_2(object sender, EventArgs e)
+    {
+        await Navigation.PushAsync(new MVVMPage());
+    }
 }
\ No newline at end of file
diff --git a/Camera.MAUI.Test/MauiProgram.cs b/Camera.MAUI.Test/MauiProgram.cs
index 33b19ea..a16c0cf 100644
--- a/Camera.MAUI.Test/MauiProgram.cs
+++ b/Camera.MAUI.Test/MauiProgram.cs
@@ -1,5 +1,8 @@
 using Microsoft.Extensions.Logging;
 using Camera.MAUI;
+using Microsoft.Maui.Hosting;
+using CommunityToolkit.Maui;
+
 namespace Camera.MAUI.Test
 {
     public static class MauiProgram
@@ -9,6 +12,8 @@ public static MauiApp CreateMauiApp()
             var builder = MauiApp.CreateBuilder();
             builder
                 .UseMauiApp<App>()
+                .UseMauiCommunityToolkit()
+                .UseMauiCommunityToolkitMediaElement()
                 .UseMauiCameraView()
                 .ConfigureFonts(fonts =>
                 {
@@ -19,7 +24,7 @@ public static MauiApp CreateMauiApp()
 #if DEBUG
 		builder.Logging.AddDebug();
 #endif
-
+            builder.Services.AddSingleton<CameraViewModel>();
             return builder.Build();
         }
     }
diff --git a/Camera.MAUI.Test/Platforms/Android/AndroidManifest.xml b/Camera.MAUI.Test/Platforms/Android/AndroidManifest.xml
index ace992e..5136136 100644
--- a/Camera.MAUI.Test/Platforms/Android/AndroidManifest.xml
+++ b/Camera.MAUI.Test/Platforms/Android/AndroidManifest.xml
@@ -6,4 +6,6 @@
   <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
   <uses-permission android:name="android.permission.CAMERA" />
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.RECORD_VIDEO" />
 </manifest>
\ No newline at end of file
diff --git a/Camera.MAUI.Test/Platforms/iOS/Info.plist b/Camera.MAUI.Test/Platforms/iOS/Info.plist
index 654e883..d7ab413 100644
--- a/Camera.MAUI.Test/Platforms/iOS/Info.plist
+++ b/Camera.MAUI.Test/Platforms/iOS/Info.plist
@@ -30,6 +30,8 @@
 	<string>Assets.xcassets/appicon.appiconset</string>
 	<key>NSCameraUsageDescription</key>
 	<string>This app needs access to the camera to take photos and scan QR codes</string>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>This app needs access to the microphone for record videos</string>
 	<key>CFBundleIdentifier</key>
 	<string></string>
 </dict>
diff --git a/Camera.MAUI.Test/SizedPage.xaml b/Camera.MAUI.Test/SizedPage.xaml
index e7e3f49..67614dc 100644
--- a/Camera.MAUI.Test/SizedPage.xaml
+++ b/Camera.MAUI.Test/SizedPage.xaml
@@ -1,17 +1,24 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
              xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit"
              x:Class="Camera.MAUI.Test.SizedPage"
              xmlns:cv="clr-namespace:Camera.MAUI;assembly=Camera.MAUI"
              Title="SizedPage" Background="white" x:Name="sizedPage">
     <ScrollView>
         <Grid>
             <VerticalStackLayout HorizontalOptions="Center" VerticalOptions="Center">
-                <cv:CameraView x:Name="cameraView" WidthRequest="300" HeightRequest="200"/>
+                <Border WidthRequest="300" HeightRequest="200">
+                    <cv:CameraView x:Name="cameraView" WidthRequest="300" HeightRequest="200" />
+                </Border>
                 <HorizontalStackLayout HorizontalOptions="Center" Margin="5">
                     <Label x:Name="cameraLabel" Text="Select a camera:" VerticalOptions="Center" BackgroundColor="White" TextColor="Black"/>
                     <Picker x:Name="cameraPicker" VerticalOptions="Center" TextColor="Black" SelectedIndexChanged="CameraPicker_SelectedIndexChanged"/>
                 </HorizontalStackLayout>
+                <HorizontalStackLayout HorizontalOptions="Center" Margin="5">
+                    <Label x:Name="microLabel" Text="Select a microphone:" VerticalOptions="Center" BackgroundColor="White" TextColor="Black"/>
+                    <Picker x:Name="microPicker" VerticalOptions="Center" TextColor="Black" SelectedIndexChanged="MicroPicker_SelectedIndexChanged"/>
+                </HorizontalStackLayout>
                 <HorizontalStackLayout HorizontalOptions="Center">
                     <Label Text="Mirrored" VerticalOptions="Center" TextColor="Black"/>
                     <CheckBox CheckedChanged="CheckBox_CheckedChanged" VerticalOptions="Center" Color="Black"/>
@@ -37,13 +44,13 @@
                     <Button Text="Stop Camera" Clicked="OnStopClicked" />
                     <Button Text="Take Photo" Clicked="OnSnapClicked" />
                 </HorizontalStackLayout>
-                <Label BindingContext="{x:Reference sizedPage}" Text="{Binding BarcodeText}" TextColor="Black" FontAttributes="Bold" HorizontalOptions="Center" />
-                <Image x:Name="snapPreview" BindingContext="{x:Reference cameraView}"
-                Aspect="AspectFit"
-                Source="dotnet_bot.png"
-                WidthRequest="250"
-                HeightRequest="100"
-                HorizontalOptions="Center" />
+                <HorizontalStackLayout HorizontalOptions="Center" Margin="5">
+                    <Button Text="Start Record" Clicked="OnStartRecordingClicked" />
+                    <Button Text="Stop Record" Clicked="OnStopRecordingClicked" />
+                </HorizontalStackLayout>
+                <Label BindingContext="{x:Reference sizedPage}" Text="{Binding BarcodeText}" TextColor="Black" FontAttributes="Bold" HorizontalOptions="Fill" HorizontalTextAlignment="Center" />
+                <Image x:Name="snapPreview" BindingContext="{x:Reference cameraView}" Aspect="AspectFit" Source="dotnet_bot.png" WidthRequest="300" HeightRequest="200" HorizontalOptions="Center" IsVisible="false"/>
+                <toolkit:MediaElement x:Name="player" ShouldAutoPlay="False" ShouldShowPlaybackControls="True" HeightRequest="300" WidthRequest="200" />
             </VerticalStackLayout>
         </Grid>
     </ScrollView>
diff --git a/Camera.MAUI.Test/SizedPage.xaml.cs b/Camera.MAUI.Test/SizedPage.xaml.cs
index 529cc5d..d25ef35 100644
--- a/Camera.MAUI.Test/SizedPage.xaml.cs
+++ b/Camera.MAUI.Test/SizedPage.xaml.cs
@@ -1,3 +1,4 @@
+using CommunityToolkit.Maui.Views;
 using System.Diagnostics;
 using ZXing.QrCode.Internal;
 
@@ -26,17 +27,23 @@ public SizedPage()
 	{
 		InitializeComponent();
         cameraView.CamerasLoaded += CameraView_CamerasLoaded;
+        cameraView.MicrophonesLoaded += CameraView_MicrophonesLoaded;
         cameraView.BarcodeDetected += CameraView_BarcodeDetected;
         cameraView.BarCodeOptions = new ZXingHelper.BarcodeDecodeOptions
         {
             AutoRotate = true,
-            PossibleFormats = { ZXing.BarcodeFormat.QR_CODE },
+            PossibleFormats = { ZXing.BarcodeFormat.QR_CODE, ZXing.BarcodeFormat.EAN_13 },
             ReadMultipleCodes = false,
             TryHarder = true,
             TryInverted = true
         };
         BindingContext = cameraView;
-        //this.SetBinding(StreamProperty, nameof(cameraView.SnapShotStream));
+    }
+
+    private void CameraView_MicrophonesLoaded(object sender, EventArgs e)
+    {
+        microPicker.ItemsSource = cameraView.Microphones;
+        microPicker.SelectedIndex = 0;
     }
 
     private void CameraView_BarcodeDetected(object sender, ZXingHelper.BarcodeEventArgs args)
@@ -66,6 +73,39 @@ private async void OnStartClicked(object sender, EventArgs e)
             cameraLabel.BackgroundColor = Colors.Red;
         }
     }
+    private async void OnStartRecordingClicked(object sender, EventArgs e)
+    {
+        if (cameraPicker.SelectedItem != null && cameraPicker.SelectedItem is CameraInfo camera)
+        {
+            //if (microPicker.SelectedItem != null && microPicker.SelectedItem is MicrophoneInfo micro)
+            //{
+                cameraLabel.BackgroundColor = Colors.White;
+                microLabel.BackgroundColor = Colors.White;
+                cameraView.Camera = camera;
+            //cameraView.Microphone = micro;
+#if IOS
+            var result = await cameraView.StartRecordingAsync(Path.Combine(FileSystem.Current.CacheDirectory, "Video.mov"));
+#else
+            var result = await cameraView.StartRecordingAsync(Path.Combine(FileSystem.Current.CacheDirectory, "Video.mp4"));
+#endif
+            Debug.WriteLine("Start recording result " + result);
+            //}
+            //else
+            //    microLabel.BackgroundColor = Colors.Red;
+        }
+        else
+            cameraLabel.BackgroundColor = Colors.Red;
+    }
+    private async void OnStopRecordingClicked(object sender, EventArgs e)
+    {
+        var result = await cameraView.StopRecordingAsync();
+        Debug.WriteLine("Stop recording result " + result);
+#if IOS
+        player.Source = MediaSource.FromFile(Path.Combine(FileSystem.Current.CacheDirectory, "Video.mov"));
+#else
+        player.Source = MediaSource.FromFile(Path.Combine(FileSystem.Current.CacheDirectory, "Video.mp4"));
+#endif
+    }
     private async void OnStopClicked(object sender, EventArgs e)
     {
         var result = await cameraView.StopCameraAsync();
@@ -107,6 +147,7 @@ private void CameraPicker_SelectedIndexChanged(object sender, EventArgs e)
                 zoomStepper.Maximum = camera.MaxZoomFactor;
             }else
                 zoomLabel.IsEnabled = zoomStepper.IsEnabled = true;
+            cameraView.Camera = camera;
         }
     }
 
@@ -130,4 +171,12 @@ private void CheckBox_CheckedChanged_1(object sender, CheckedChangedEventArgs e)
             snapPreview.RemoveBinding(Image.SourceProperty);
         cameraView.TakeAutoSnapShot = e.Value;
     }
+
+    private void MicroPicker_SelectedIndexChanged(object sender, EventArgs e)
+    {
+        if (microPicker.SelectedItem != null && microPicker.SelectedItem is MicrophoneInfo micro)
+        {
+            cameraView.Microphone = micro;
+        }
+    }
 }
\ No newline at end of file
diff --git a/Camera.MAUI/Apple/MauiCameraView.cs b/Camera.MAUI/Apple/MauiCameraView.cs
index 6f27303..0287f38 100644
--- a/Camera.MAUI/Apple/MauiCameraView.cs
+++ b/Camera.MAUI/Apple/MauiCameraView.cs
@@ -7,34 +7,29 @@
 using CoreMedia;
 using CoreVideo;
 using Foundation;
-using System.Dynamic;
+using MediaPlayer;
+using System.IO;
 using UIKit;
 
 namespace Camera.MAUI.Platforms.Apple;
 
-internal class MauiCameraView : UIView, IAVCaptureVideoDataOutputSampleBufferDelegate
+internal class MauiCameraView : UIView, IAVCaptureVideoDataOutputSampleBufferDelegate, IAVCaptureFileOutputRecordingDelegate
 {
-    public CameraInfo Camera { get; set; }
-    public float MinZoomFactor { get; } = 1f;
-    public float MaxZoomFactor
-    {
-        get
-        {
-            if (captureDevice != null)
-                return (float)captureDevice.ActiveFormat.VideoMaxZoomFactor;
-            else
-                return 1f;
-        }
-    }
-
+    private CameraInfo Camera { get; set; }
     private readonly List<CameraInfo> Cameras = new();
-    private AVCaptureDevice[] devices;
+    private readonly List<MicrophoneInfo> Micros = new();
+    private MicrophoneInfo Microphone { get; set; }
+    private AVCaptureDevice[] camDevices;
+    private AVCaptureDevice[] micDevices;
     private readonly CameraView cameraView;
     private readonly AVCaptureVideoPreviewLayer PreviewLayer;
     private readonly AVCaptureVideoDataOutput videoDataOutput;
+    private AVCaptureMovieFileOutput recordOutput;
     private readonly AVCaptureSession captureSession;
     private AVCaptureDevice captureDevice;
+    private AVCaptureDevice micDevice;
     private AVCaptureInput captureInput = null;
+    private AVCaptureInput micInput = null;
     private bool started = false;
     private CIImage lastCapture;
     private readonly object lockCapture = new();
@@ -81,8 +76,8 @@ private void InitDevices()
             try
             {
                 var deviceDescoverySession = AVCaptureDeviceDiscoverySession.Create(new AVCaptureDeviceType[] { AVCaptureDeviceType.BuiltInWideAngleCamera }, AVMediaTypes.Video, AVCaptureDevicePosition.Unspecified);
-                devices = deviceDescoverySession.Devices;
-                foreach (var device in devices)
+                camDevices = deviceDescoverySession.Devices;
+                foreach (var device in camDevices)
                 {
                     CameraPosition position = device.Position switch
                     {
@@ -99,33 +94,95 @@ private void InitDevices()
                     });
                 }
                 Camera = Cameras.FirstOrDefault();
+                deviceDescoverySession.Dispose();
+                var aSession = AVCaptureDeviceDiscoverySession.Create(new AVCaptureDeviceType[] { AVCaptureDeviceType.BuiltInMicrophone }, AVMediaTypes.Audio, AVCaptureDevicePosition.Unspecified);
+                micDevices = aSession.Devices;
+                foreach (var device in micDevices)
+                    Micros.Add(new MicrophoneInfo { Name = device.LocalizedName, DeviceId = device.UniqueID });
+                Microphone = Micros.FirstOrDefault();
+                aSession.Dispose();
+                initiated = true;
                 if (cameraView != null)
                 {
                     cameraView.Cameras.Clear();
+                    foreach (var micro in Micros) cameraView.Microphones.Add(micro);
                     foreach (var cam in Cameras) cameraView.Cameras.Add(cam);
+                    cameraView.RefreshDevices();
                 }
-                deviceDescoverySession.Dispose();
-                initiated = true;
             }
             catch
             {
             }
         }
     }
+    public async Task<CameraResult> StartRecordingAsync(string file)
+    {
+        CameraResult result = CameraResult.Success;
+        if (initiated)
+        {
+            if (started) StopCamera();
+            if (await CameraView.RequestPermissions(true))
+            {
+                if (Camera != null && captureSession != null)
+                {
+                    try
+                    {
+                        frames = 0;
+                        captureDevice = camDevices.First(d => d.UniqueID == Camera.DeviceId);
+                        captureInput = new AVCaptureDeviceInput(captureDevice, out var err);
+                        captureSession.AddInput(captureInput);
+                        micDevice = micDevices.First(d => d.UniqueID == Microphone.DeviceId);
+                        micInput = new AVCaptureDeviceInput(micDevice, out err);
+                        captureSession.AddInput(micInput);
+
+                        captureSession.AddOutput(videoDataOutput);
+                        recordOutput = new AVCaptureMovieFileOutput();
+                        captureSession.AddOutput(recordOutput);
+
+                        var movieFileOutputConnection = recordOutput.Connections[0];
+                        movieFileOutputConnection.VideoOrientation = (AVCaptureVideoOrientation)UIDevice.CurrentDevice.Orientation;
+                        captureSession.StartRunning();
+                        if (!File.Exists(file)) File.Create(file).Close();
+
+                        recordOutput.StartRecordingToOutputFile(NSUrl.FromFilename(file), this);
+                        UpdateMirroredImage();
+                        SetZoomFactor(cameraView.ZoomFactor);
+                        started = true;
+                    }
+                    catch
+                    {
+                        result = CameraResult.AccessError;
+                    }
+                }
+                else
+                    result = CameraResult.AccessError;
+            }
+            else
+                result = CameraResult.AccessDenied;
+        }
+        else
+            result = CameraResult.NotInitiated;
+        return result;
+    }
+    public Task<CameraResult> StopRecordingAsync()
+    {
+        return StartCameraAsync();
+    }
+
     public async Task<CameraResult> StartCameraAsync()
     {
         CameraResult result = CameraResult.Success;
         if (initiated)
         {
             if (started) StopCamera();
-            if (await RequestPermissions())
+            if (await CameraView.RequestPermissions())
             {
                 if (Camera != null && captureSession != null)
                 {
                     try
                     {
                         frames = 0;
-                        captureDevice = devices.First(d => d.UniqueID == Camera.DeviceId);
+                        captureDevice = camDevices.First(d => d.UniqueID == Camera.DeviceId);
                         captureInput = new AVCaptureDeviceInput(captureDevice, out var err);
                         captureSession.AddInput(captureInput);
                         captureSession.AddOutput(videoDataOutput);
@@ -159,13 +216,18 @@ public CameraResult StopCamera()
                 {
                     if (captureSession.Running)
                         captureSession.StopRunning();
+                    if (recordOutput != null)
+                    {
+                        recordOutput.StopRecording();
+                        captureSession.RemoveOutput(recordOutput);
+                        recordOutput.Dispose();
+                        recordOutput = null;
+                    }
                     captureSession.RemoveOutput(videoDataOutput);
-
-                    if (captureInput != null && captureSession.Inputs.Length > 0 && captureSession.Inputs.Contains(captureInput))
+                    foreach (var input in captureSession.Inputs)
                     {
-                        captureSession.RemoveInput(captureInput);
-                        captureInput.Dispose();
-                        captureInput = null;
+                        captureSession.RemoveInput(input);
+                        input.Dispose();
                     }
                 }
                 started = false;
@@ -191,9 +253,13 @@ public async void UpdateCamera()
     {
         if (cameraView != null && cameraView.Camera != null)
         {
-            if (started) StopCamera();
-            Camera = cameraView.Camera;
-            if (started) await StartCameraAsync();
+            if (started)
+            {
+                StopCamera();
+                Camera = cameraView.Camera;
+                await StartCameraAsync();
+            }else
+                Camera = cameraView.Camera;
         }
     }
     public void UpdateMirroredImage()
@@ -206,17 +272,18 @@ public void UpdateMirroredImage()
                 PreviewLayer.Connection.VideoMirrored = true;
             else
                 PreviewLayer.Connection.VideoMirrored = false;
+
             UpdateTorch();
         }
     }
     public void SetZoomFactor(float zoom)
     {
-        if (captureDevice != null)
+        if (Camera != null && captureDevice != null)
         {
             captureDevice.LockForConfiguration(out NSError error);
             if (error == null)
             {
-                captureDevice.VideoZoomFactor = Math.Max(MinZoomFactor, Math.Min(zoom, MaxZoomFactor));
+                captureDevice.VideoZoomFactor = Math.Max(Camera.MinZoomFactor, Math.Min(zoom, Camera.MaxZoomFactor));
                 captureDevice.UnlockForConfiguration();
             }
         }
@@ -452,17 +519,6 @@ public void DidOutputSampleBuffer(AVCaptureOutput captureOutput, CMSampleBuffer
         }
     }
 
-    private static async Task<bool> RequestPermissions()
-    {
-        var status = await Permissions.CheckStatusAsync<Permissions.Camera>();
-        if (status != PermissionStatus.Granted)
-        {
-            status = await Permissions.RequestAsync<Permissions.Camera>();
-            if (status != PermissionStatus.Granted) return false;
-        }
-        return true;
-    }
-
     public override void LayoutSubviews()
     {
         base.LayoutSubviews();
@@ -486,5 +542,10 @@ public override void LayoutSubviews()
         PreviewLayer.Transform = transform;
         PreviewLayer.Frame = Layer.Bounds;
     }
+
+    public void FinishedRecording(AVCaptureFileOutput captureOutput, NSUrl outputFileUrl, NSObject[] connections, NSError error)
+    {
+        
+    }
 }
 #endif
diff --git a/Camera.MAUI/Camera.MAUI.csproj b/Camera.MAUI/Camera.MAUI.csproj
index bcc3468..1e622c8 100644
--- a/Camera.MAUI/Camera.MAUI.csproj
+++ b/Camera.MAUI/Camera.MAUI.csproj
@@ -11,7 +11,7 @@
 
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">11.0</SupportedOSPlatformVersion>
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst'">13.1</SupportedOSPlatformVersion>
-		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">21.0</SupportedOSPlatformVersion>
+		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">28.0</SupportedOSPlatformVersion>
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">10.0.17763.0</SupportedOSPlatformVersion>
 		<TargetPlatformMinVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">10.0.17763.0</TargetPlatformMinVersion>
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'tizen'">6.5</SupportedOSPlatformVersion>
@@ -29,8 +29,8 @@
 		<Authors>hjam40</Authors>
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
-		<Version>1.2.1</Version>
-		<PackageReleaseNotes>Added MVVM snapshot properties</PackageReleaseNotes>
+		<Version>1.3</Version>
+		<PackageReleaseNotes>Added Video/audio recording</PackageReleaseNotes>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(TargetFramework)'=='net7.0-ios'">
@@ -44,9 +44,6 @@
 	</ItemGroup>
 
 	<ItemGroup Condition="'$(TargetFramework)' == 'net7.0-android'">
-    <PackageReference Include="Xamarin.AndroidX.Camera.Camera2" Version="1.2.0" />
-    <PackageReference Include="Xamarin.AndroidX.Camera.Lifecycle" Version="1.2.0" />
-    <PackageReference Include="Xamarin.AndroidX.Camera.View" Version="1.2.0" />
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/Camera.MAUI/CameraResult.cs b/Camera.MAUI/CameraResult.cs
index b657e7d..1097eeb 100644
--- a/Camera.MAUI/CameraResult.cs
+++ b/Camera.MAUI/CameraResult.cs
@@ -7,5 +7,6 @@ public enum CameraResult
     NoCameraSelected,
     AccessError,
     NoVideoFormatsAvailable,
-    NotInitiated
+    NotInitiated,
+    NoMicrophoneSelected
 }
diff --git a/Camera.MAUI/CameraView.cs b/Camera.MAUI/CameraView.cs
index 9f14306..cd48697 100644
--- a/Camera.MAUI/CameraView.cs
+++ b/Camera.MAUI/CameraView.cs
@@ -3,6 +3,7 @@
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using ZXing;
+using static Microsoft.Maui.ApplicationModel.Permissions;
 #if IOS || MACCATALYST
 using DecodeDataType = UIKit.UIImage;
 #elif ANDROID
@@ -20,7 +21,11 @@ public class CameraView : View, ICameraView
     public static readonly BindableProperty FlashModeProperty = BindableProperty.Create(nameof(FlashMode), typeof(FlashMode), typeof(CameraView), FlashMode.Disabled);
     public static readonly BindableProperty TorchEnabledProperty = BindableProperty.Create(nameof(TorchEnabled), typeof(bool), typeof(CameraView), false);
     public static readonly BindableProperty CamerasProperty = BindableProperty.Create(nameof(Cameras), typeof(ObservableCollection<CameraInfo>), typeof(CameraView), new ObservableCollection<CameraInfo>());
+    public static readonly BindableProperty NumCamerasDetectedProperty = BindableProperty.Create(nameof(NumCamerasDetected), typeof(int), typeof(CameraView), 0);
     public static readonly BindableProperty CameraProperty = BindableProperty.Create(nameof(Camera), typeof(CameraInfo), typeof(CameraView), null, propertyChanged:CameraChanged);
+    public static readonly BindableProperty MicrophonesProperty = BindableProperty.Create(nameof(Microphones), typeof(ObservableCollection<MicrophoneInfo>), typeof(CameraView), new ObservableCollection<MicrophoneInfo>());
+    public static readonly BindableProperty NumMicrophonesDetectedProperty = BindableProperty.Create(nameof(NumMicrophonesDetected), typeof(int), typeof(CameraView), 0);
+    public static readonly BindableProperty MicrophoneProperty = BindableProperty.Create(nameof(Microphone), typeof(MicrophoneInfo), typeof(CameraView), null);
     public static readonly BindableProperty MirroredImageProperty = BindableProperty.Create(nameof(MirroredImage), typeof(bool), typeof(CameraView), false);
     public static readonly BindableProperty BarCodeDetectionEnabledProperty = BindableProperty.Create(nameof(BarCodeDetectionEnabled), typeof(bool), typeof(CameraView), false);
     public static readonly BindableProperty BarCodeDetectionFrameRateProperty = BindableProperty.Create(nameof(BarCodeDetectionFrameRate), typeof(int), typeof(CameraView), 10);
@@ -33,6 +38,9 @@ public class CameraView : View, ICameraView
     public static readonly BindableProperty SnapShotStreamProperty = BindableProperty.Create(nameof(SnapShotStream), typeof(Stream), typeof(CameraView), null, BindingMode.OneWayToSource);
     public static readonly BindableProperty TakeAutoSnapShotProperty = BindableProperty.Create(nameof(TakeAutoSnapShot), typeof(bool), typeof(CameraView), false, propertyChanged:TakeAutoSnapShotChanged);
     public static readonly BindableProperty AutoSnapShotAsImageSourceProperty = BindableProperty.Create(nameof(AutoSnapShotAsImageSource), typeof(bool), typeof(CameraView), false);
+    public static readonly BindableProperty AutoStartPreviewProperty = BindableProperty.Create(nameof(AutoStartPreview), typeof(bool), typeof(CameraView), false, propertyChanged: AutoStartPreviewChanged);
+    public static readonly BindableProperty AutoRecordingFileProperty = BindableProperty.Create(nameof(AutoRecordingFile), typeof(string), typeof(CameraView), string.Empty);
+    public static readonly BindableProperty AutoStartRecordingProperty = BindableProperty.Create(nameof(AutoStartRecording), typeof(bool), typeof(CameraView), false, propertyChanged: AutoStartRecordingChanged);
 
     /// <summary>
     /// Flash mode for take a photo. This is a bindable property.
@@ -59,6 +67,14 @@ public ObservableCollection<CameraInfo> Cameras
         set { SetValue(CamerasProperty, value); }
     }
     /// <summary>
+    /// Indicates the number of available cameras in the device.
+    /// </summary>
+    public int NumCamerasDetected
+    {
+        get { return (int)GetValue(NumCamerasDetectedProperty); }
+        set { SetValue(NumCamerasDetectedProperty, value); }
+    }
+    /// <summary>
     /// Set the camera to use by the controler. This is a bindable property.
     /// </summary>
     public CameraInfo Camera
@@ -67,6 +83,30 @@ public CameraInfo Camera
         set { SetValue(CameraProperty, value); }
     }
     /// <summary>
+    /// List of available microphones in the device. This is a bindable property.
+    /// </summary>
+    public ObservableCollection<MicrophoneInfo> Microphones
+    {
+        get { return (ObservableCollection<MicrophoneInfo>)GetValue(MicrophonesProperty); }
+        set { SetValue(MicrophonesProperty, value); }
+    }
+    /// <summary>
+    /// Indicates the number of available microphones in the device.
+    /// </summary>
+    public int NumMicrophonesDetected
+    {
+        get { return (int)GetValue(NumMicrophonesDetectedProperty); }
+        set { SetValue(NumMicrophonesDetectedProperty, value); }
+    }
+    /// <summary>
+    /// Set the microphone to use by the controler. This is a bindable property.
+    /// </summary>
+    public MicrophoneInfo Microphone
+    {
+        get { return (MicrophoneInfo)GetValue(MicrophoneProperty); }
+        set { SetValue(MicrophoneProperty, value); }
+    }
+    /// <summary>
     /// Turns a mirror image of the camera on and off. This is a bindable property.
     /// </summary>
     public bool MirroredImage
@@ -192,6 +232,30 @@ public bool AutoSnapShotAsImageSource
         get { return (bool)GetValue(AutoSnapShotAsImageSourceProperty); }
         set { SetValue(AutoSnapShotAsImageSourceProperty, value); }
     }
+    /// <summary>
+    /// Starts/Stops the Preview if camera property has been set
+    /// </summary>
+    public bool AutoStartPreview
+    {
+        get { return (bool)GetValue(AutoStartPreviewProperty); }
+        set { SetValue(AutoStartPreviewProperty, value); }
+    }
+    /// <summary>
+    /// Full path to file where record video will be recorded.
+    /// </summary>
+    public string AutoRecordingFile
+    {
+        get { return (string)GetValue(AutoRecordingFileProperty); }
+        set { SetValue(AutoRecordingFileProperty, value); }
+    }
+    /// <summary>
+    /// Starts/Stops record video to AutoRecordingFile if camera and microphone properties have been set
+    /// </summary>
+    public bool AutoStartRecording
+    {
+        get { return (bool)GetValue(AutoStartRecordingProperty); }
+        set { SetValue(AutoStartRecordingProperty, value); }
+    }
     public delegate void BarcodeResultHandler(object sender, BarcodeEventArgs args);
     /// <summary>
     /// Event launched every time a code is detected in the image if "BarCodeDetectionEnabled" is set to true.
@@ -201,6 +265,10 @@ public bool AutoSnapShotAsImageSource
     /// Event launched when "Cameras" property has been loaded.
     /// </summary>
     public event EventHandler CamerasLoaded;
+    /// <summary>
+    /// Event launched when "Microphones" property has been loaded.
+    /// </summary>
+    public event EventHandler MicrophonesLoaded;
 
     private readonly BarcodeReaderGeneric BarcodeReader;
     internal DateTime lastSnapshot = DateTime.Now;
@@ -212,7 +280,11 @@ public CameraView()
     }
     private void CameraView_HandlerChanged(object sender, EventArgs e)
     {
-        if (Handler != null) CamerasLoaded?.Invoke(this, EventArgs.Empty);
+        if (Handler != null)
+        {
+            CamerasLoaded?.Invoke(this, EventArgs.Empty);
+            MicrophonesLoaded?.Invoke(this, EventArgs.Empty);
+        }
     }
     internal void RefreshSnapshot(ImageSource img)
     {
@@ -247,19 +319,35 @@ internal void DecodeBarcode(DecodeDataType data)
             }
             if (results?.Length > 0)
             {
-                BarCodeResults = results;
-                OnPropertyChanged(nameof(BarCodeResults));
-                BarcodeDetected?.Invoke(this, new BarcodeEventArgs { Result = results });
+                bool refresh = true;
+                if (BarCodeResults != null)
+                {
+                    foreach ( var result in results)
+                    {
+                        refresh = BarCodeResults.FirstOrDefault(b => b.Text == result.Text && b.BarcodeFormat == result.BarcodeFormat) == null;
+                        if (refresh) break;
+                    }
+                }
+                if (refresh)
+                {
+                    BarCodeResults = results;
+                    OnPropertyChanged(nameof(BarCodeResults));
+                    BarcodeDetected?.Invoke(this, new BarcodeEventArgs { Result = results });
+                }
             }
         }
         catch {}
     }
-    private static void CameraChanged(BindableObject bindable, object oldValue, object newValue)
+    private static async void CameraChanged(BindableObject bindable, object oldValue, object newValue)
     {
         if (newValue != null && oldValue != newValue && bindable is CameraView cameraView && newValue is CameraInfo)
         {
             cameraView.OnPropertyChanged(nameof(MinZoomFactor));
             cameraView.OnPropertyChanged(nameof(MaxZoomFactor));
+            if (cameraView.AutoStartPreview)
+            {
+                await cameraView.StartCameraAsync();
+            }
         }
     }
     private static void TakeAutoSnapShotChanged(BindableObject bindable, object oldValue, object newValue)
@@ -269,6 +357,39 @@ private static void TakeAutoSnapShotChanged(BindableObject bindable, object oldV
             cameraView.RefreshSnapshot(cameraView.GetSnapShot(cameraView.AutoSnapShotFormat));
         }
     }
+    private static async void AutoStartPreviewChanged(BindableObject bindable, object oldValue, object newValue)
+    {
+        if (oldValue != newValue && bindable is CameraView control)
+        {
+            try
+            {
+                if ((bool)newValue)
+                    await control.StartCameraAsync();
+                else
+                    await control.StopCameraAsync();
+            }
+            catch { }
+                    
+        }
+    }
+    private static async void AutoStartRecordingChanged(BindableObject bindable, object oldValue, object newValue)
+    {
+        if (oldValue != newValue && bindable is CameraView control)
+        {
+            try
+            {
+                if ((bool)newValue)
+                {
+                    if (!string.IsNullOrEmpty(control.AutoRecordingFile))
+                        await control.StartRecordingAsync(control.AutoRecordingFile);
+                }
+                else
+                    await control.StopRecordingAsync();
+            }
+            catch { }
+
+        }
+    }
     private static void BarCodeOptionsChanged(BindableObject bindable, object oldValue, object newValue)
     {
         if (newValue != null && oldValue != newValue && bindable is CameraView cameraView && newValue is BarcodeDecodeOptions options)
@@ -287,15 +408,47 @@ private static void BarCodeOptionsChanged(BindableObject bindable, object oldVal
     public async Task<CameraResult> StartCameraAsync()
     {
         CameraResult result = CameraResult.AccessError;
-        if (Camera != null && Handler != null && Handler is CameraViewHandler handler)
+        if (Camera != null)
         {
-            result = await handler.StartCameraAsync();
-            if (result == CameraResult.Success)
+            if (Handler != null && Handler is CameraViewHandler handler)
             {
-                OnPropertyChanged(nameof(MinZoomFactor));
-                OnPropertyChanged(nameof(MaxZoomFactor));
+                result = await handler.StartCameraAsync();
+                if (result == CameraResult.Success)
+                {
+                    BarCodeResults = null;
+                    OnPropertyChanged(nameof(MinZoomFactor));
+                    OnPropertyChanged(nameof(MaxZoomFactor));
+                }
             }
         }
+        else
+            result = CameraResult.NoCameraSelected;
+
+        return result;
+    }
+    /// <summary>
+    /// Start recording a video async. "Camera" property must not be null.
+    /// <paramref name="file"/> Full path to file where video will be stored.
+    /// </summary>
+    public async Task<CameraResult> StartRecordingAsync(string file)
+    {
+        CameraResult result = CameraResult.AccessError;
+        if (Camera != null)
+        {
+            if (Handler != null && Handler is CameraViewHandler handler)
+            {
+                result = await handler.StartRecordingAsync(file);
+                if (result == CameraResult.Success)
+                {
+                    BarCodeResults = null;
+                    OnPropertyChanged(nameof(MinZoomFactor));
+                    OnPropertyChanged(nameof(MaxZoomFactor));
+                }
+            }
+        }
+        else
+            result = CameraResult.NoCameraSelected;
+
         return result;
     }
     /// <summary>
@@ -311,6 +464,18 @@ public async Task<CameraResult> StopCameraAsync()
         return result;
     }
     /// <summary>
+    /// Stop recording a video async.
+    /// </summary>
+    public async Task<CameraResult> StopRecordingAsync()
+    {
+        CameraResult result = CameraResult.AccessError;
+        if (Handler != null && Handler is CameraViewHandler handler)
+        {
+            result = await handler.StopRecordingAsync();
+        }
+        return result;
+    }
+    /// <summary>
     /// Takes a capture form the active camera playback.
     /// </summary>
     /// <param name="imageFormat">The capture image format</param>
@@ -336,4 +501,41 @@ public async Task<bool> SaveSnapShot(ImageFormat imageFormat, string SnapFilePat
         }
         return result;
     }
+    internal void RefreshDevices()
+    {
+        Task.Run(() => { 
+            OnPropertyChanged(nameof(Cameras)); 
+            NumCamerasDetected = Cameras.Count;
+            OnPropertyChanged(nameof(Microphones));
+            NumMicrophonesDetected = Microphones.Count;
+        });
+    }
+    public static async Task<bool> RequestPermissions(bool withMic = false, bool withStorageWrite = false)
+    {
+        var status = await Permissions.CheckStatusAsync<Permissions.Camera>();
+        if (status != PermissionStatus.Granted)
+        {
+            status = await Permissions.RequestAsync<Permissions.Camera>();
+            if (status != PermissionStatus.Granted) return false;
+        }
+        if (withMic)
+        {
+            status = await Permissions.CheckStatusAsync<Permissions.Microphone>();
+            if (status != PermissionStatus.Granted)
+            {
+                status = await Permissions.RequestAsync<Permissions.Microphone>();
+                if (status != PermissionStatus.Granted) return false;
+            }
+        }
+        if (withStorageWrite)
+        {
+            status = await Permissions.CheckStatusAsync<Permissions.StorageWrite>();
+            if (status != PermissionStatus.Granted)
+            {
+                status = await Permissions.RequestAsync<Permissions.StorageWrite>();
+                if (status != PermissionStatus.Granted) return false;
+            }
+        }
+        return true;
+    }
 }
\ No newline at end of file
diff --git a/Camera.MAUI/CameraViewHandler.cs b/Camera.MAUI/CameraViewHandler.cs
index 69389c1..ebacb3c 100644
--- a/Camera.MAUI/CameraViewHandler.cs
+++ b/Camera.MAUI/CameraViewHandler.cs
@@ -72,32 +72,22 @@ public static void MapZoomFactor(CameraViewHandler handler, CameraView cameraVie
 #endif
     }
 
-    public float GetMinZoomFactor()
+    public Task<CameraResult> StartCameraAsync()
     {
         if (PlatformView != null)
         {
 #if WINDOWS || ANDROID || IOS || MACCATALYST
-            return PlatformView.MinZoomFactor;
+            return PlatformView.StartCameraAsync();
 #endif
         }
-        return 1f;
+        return Task.Run(() => { return CameraResult.AccessError; });
     }
-    public float GetMaxZoomFactor()
+    public Task<CameraResult> StartRecordingAsync(string file)
     {
         if (PlatformView != null)
         {
-#if WINDOWS || ANDROID || IOS || MACCATALYST
-            return PlatformView.MaxZoomFactor;
-#endif
-        }
-        return 1f;
-    }
-    public Task<CameraResult> StartCameraAsync()
-    {
-        if (PlatformView != null)
-        {
-#if WINDOWS || ANDROID || IOS || MACCATALYST
-            return PlatformView.StartCameraAsync();
+#if WINDOWS || ANDROID || IOS
+            return PlatformView.StartRecordingAsync(file);
 #endif
         }
         return Task.Run(() => { return CameraResult.AccessError; });
@@ -112,6 +102,16 @@ public Task<CameraResult> StopCameraAsync()
             var task = new Task<CameraResult>(() => { return PlatformView.StopCamera(); });
             task.Start();
             return task;
+#endif
+        }
+        return Task.Run(() => { return CameraResult.AccessError; });
+    }
+    public Task<CameraResult> StopRecordingAsync()
+    {
+        if (PlatformView != null)
+        {
+#if WINDOWS || ANDROID || IOS || MACCATALYST
+            return PlatformView.StopRecordingAsync();
 #endif
         }
         return Task.Run(() => { return CameraResult.AccessError; });
diff --git a/Camera.MAUI/MicrophoneInfo.cs b/Camera.MAUI/MicrophoneInfo.cs
new file mode 100644
index 0000000..944f421
--- /dev/null
+++ b/Camera.MAUI/MicrophoneInfo.cs
@@ -0,0 +1,11 @@
+namespace Camera.MAUI;
+
+public class MicrophoneInfo
+{
+    public string Name { get; internal set; }
+    public string DeviceId { get; internal set; }
+    public override string ToString()
+    {
+        return Name;
+    }
+}
diff --git a/Camera.MAUI/Platforms/Android/MauiCameraView.cs b/Camera.MAUI/Platforms/Android/MauiCameraView.cs
index 692e11d..ee8ba31 100644
--- a/Camera.MAUI/Platforms/Android/MauiCameraView.cs
+++ b/Camera.MAUI/Platforms/Android/MauiCameraView.cs
@@ -1,67 +1,66 @@
 using Android.Content;
 using Android.Widget;
-using AndroidX.Camera.View;
-using AndroidX.Camera.Lifecycle;
-using AndroidX.Camera.Core;
 using Java.Util.Concurrent;
 using Android.Graphics;
-using AndroidX.Camera.Core.Impl;
-using AndroidX.Camera.Camera2.InterOp;
 using CameraCharacteristics = Android.Hardware.Camera2.CameraCharacteristics;
 using Android.Hardware.Camera2;
+using Android.Media;
+using Android.Views;
+using Android.Util;
+using Android.OS;
+using Android.Hardware.Camera2.Params;
+using Size = Android.Util.Size;
+using Class = Java.Lang.Class;
+using Android.Provider;
+using static Microsoft.Maui.ApplicationModel.Permissions;
 
 namespace Camera.MAUI.Platforms.Android;
 
 internal class MauiCameraView: GridLayout
 {
-    public CameraInfo Camera { get; set; }
-    public float MinZoomFactor
-    {
-        get
-        {
-            if (camera != null)
-                return (camera.CameraInfo.ZoomState.Value as IZoomState).MinZoomRatio;
-            else
-                return 1f;
-        }
-    }
-    public float MaxZoomFactor
-    {
-        get
-        {
-            if (camera != null)
-                return (camera.CameraInfo.ZoomState.Value as IZoomState).MaxZoomRatio;
-            else
-                return 1f;
-        }
-    }
-    private record InternalCameraInfo
-    {
-        public CameraSelector CameraSelector { get; set; }
-        public string CameraId { get; set; }
-    }
+    private CameraInfo Camera { get; set; }
+    //private MicrophoneInfo Microphone { get; set; }
     private readonly List<CameraInfo> Cameras = new();
-    private readonly List<InternalCameraInfo> InternalCameras = new();
+    private readonly List<MicrophoneInfo> Micros = new();
+
     private readonly CameraView cameraView;
-    private readonly PreviewView previewView;
     private IExecutorService executorService;
-    private ImageAnalysis imageAnalyzer;
-    private ImageAnalyzer frameAnalyzer;
-    private ProcessCameraProvider cameraProvider;
-    private ICamera camera;
-    private Preview cameraPreview;
     private bool started = false;
-    private PreviewView.ImplementationMode currentImplementationMode = PreviewView.ImplementationMode.Performance;
     private int frames = 0;
     private bool initiated = false;
     private bool snapping = false;
+    private bool recording = false;
+    private readonly Context context;
+
+    private readonly TextureView textureView;
+    public CameraCaptureSession previewSession;
+    public MediaRecorder mediaRecorder;
+    private CaptureRequest.Builder previewBuilder;
+    private CameraDevice cameraDevice;
+    private readonly MyCameraStateCallback stateListener;
+    private Size videoSize;
+    private CameraManager cameraManager;
+    private AudioManager audioManager;
+    private HandlerThread backgroundThread;
+    private Handler backgroundHandler;
+    private readonly System.Timers.Timer timer;
+    private readonly SparseIntArray ORIENTATIONS = new();
+
 
     public MauiCameraView(Context context, CameraView cameraView) : base(context)
     {
+        this.context = context;
         this.cameraView = cameraView;
-        previewView = new PreviewView(context);
-        previewView.SetScaleType(PreviewView.ScaleType.FillCenter);
-        AddView(previewView);
+
+        textureView = new(context);
+        timer = new(33.3);
+        timer.Elapsed += Timer_Elapsed;
+        stateListener = new MyCameraStateCallback(this);
+        AddView(textureView);
+        ORIENTATIONS.Append((int)SurfaceOrientation.Rotation0, 90);
+        ORIENTATIONS.Append((int)SurfaceOrientation.Rotation90, 0);
+        ORIENTATIONS.Append((int)SurfaceOrientation.Rotation180, 270);
+        ORIENTATIONS.Append((int)SurfaceOrientation.Rotation270, 180);
         InitDevices();
     }
 
@@ -69,128 +68,195 @@ private void InitDevices()
     {
         if (!initiated)
         {
-            try
+            cameraManager = (CameraManager)context.GetSystemService(Context.CameraService);
+            audioManager = (AudioManager)context.GetSystemService(Context.AudioService);
+            foreach (var id in cameraManager.GetCameraIdList())
             {
-                var initCameraProvider = ProcessCameraProvider.GetInstance(Context);
-                cameraProvider = (ProcessCameraProvider)initCameraProvider.Get();
-                cameraPreview = new Preview.Builder().Build();
-                cameraPreview.SetSurfaceProvider(previewView.SurfaceProvider);
-                executorService = Executors.NewSingleThreadExecutor();
-                frameAnalyzer = new ImageAnalyzer();
-                frameAnalyzer.FrameReady += FrameAnalyzer_FrameReady;
-                imageAnalyzer = new ImageAnalysis.Builder().SetBackpressureStrategy(ImageAnalysis.StrategyKeepOnlyLatest).Build();
-                imageAnalyzer.SetAnalyzer(executorService, frameAnalyzer);
-
-                if (cameraProvider != null)
+                var cameraInfo = new CameraInfo { DeviceId = id, MinZoomFactor = 1 };
+                var chars = cameraManager.GetCameraCharacteristics(id);
+                if ((int)(chars.Get(CameraCharacteristics.LensFacing) as Java.Lang.Number) == (int)LensFacing.Back)
                 {
-                    foreach (var camInfo in cameraProvider.AvailableCameraInfos)
-                    {
-                        var c2cInfo = Camera2CameraInfo.From(camInfo);
-                        if ((int)(c2cInfo.GetCameraCharacteristic(CameraCharacteristics.LensFacing) as Java.Lang.Number) == (int)LensFacing.Back)
-                            Cameras.Add(new CameraInfo 
-                            { 
-                                Name = "Back Camera", DeviceId = c2cInfo.CameraId, Position = CameraPosition.Back,
-                                HasFlashUnit = camInfo.HasFlashUnit,
-                                MinZoomFactor = (camInfo.ZoomState.Value as IZoomState).MinZoomRatio,
-                                MaxZoomFactor = (camInfo.ZoomState.Value as IZoomState).MaxZoomRatio
-                            });
-                        else if ((int)(c2cInfo.GetCameraCharacteristic(CameraCharacteristics.LensFacing) as Java.Lang.Number) == (int)LensFacing.Front)
-                            Cameras.Add(new CameraInfo 
-                            { 
-                                Name = "Front Camera", DeviceId = c2cInfo.CameraId, Position = CameraPosition.Front,
-                                HasFlashUnit = camInfo.HasFlashUnit,
-                                MinZoomFactor = (camInfo.ZoomState.Value as IZoomState).MinZoomRatio,
-                                MaxZoomFactor = (camInfo.ZoomState.Value as IZoomState).MaxZoomRatio
-                            });
-                        else
-                        {
-                            Cameras.Add(new CameraInfo 
-                            {
-                                Name = "Camera " + c2cInfo.CameraId, DeviceId = c2cInfo.CameraId, Position = CameraPosition.Unknow,
-                                HasFlashUnit = camInfo.HasFlashUnit,
-                                MinZoomFactor = (camInfo.ZoomState.Value as IZoomState).MinZoomRatio,
-                                MaxZoomFactor = (camInfo.ZoomState.Value as IZoomState).MaxZoomRatio
-                            });
-                        }
-                        InternalCameras.Add(new InternalCameraInfo { CameraSelector = camInfo.CameraSelector, CameraId = c2cInfo.CameraId });
-                    }
-                    Camera = Cameras.FirstOrDefault();
-                    if (cameraView != null)
-                    {
-                        cameraView.Cameras.Clear();
-                        foreach (var cam in Cameras) cameraView.Cameras.Add(cam);
-                    }
+                    cameraInfo.Name = "Back Camera";
+                    cameraInfo.Position = CameraPosition.Back;
                 }
-                initiated = true;
+                else if ((int)(chars.Get(CameraCharacteristics.LensFacing) as Java.Lang.Number) == (int)LensFacing.Front)
+                {
+                    cameraInfo.Name = "Front Camera";
+                    cameraInfo.Position = CameraPosition.Front;
+                }
+                else
+                {
+                    cameraInfo.Name = "Camera " + id;
+                    cameraInfo.Position = CameraPosition.Unknow;
+                }
+                cameraInfo.MaxZoomFactor = (float)(chars.Get(CameraCharacteristics.ScalerAvailableMaxDigitalZoom) as Java.Lang.Number) * 10;
+                cameraInfo.HasFlashUnit = (bool)(chars.Get(CameraCharacteristics.FlashInfoAvailable) as Java.Lang.Boolean);
+                Cameras.Add(cameraInfo);
             }
-            catch
+            foreach (var device in audioManager.Microphones)
             {
+                Micros.Add(new MicrophoneInfo { Name = "Microphone " + device.Type.ToString() + " " + device.Address, DeviceId = device.Id.ToString() });
+            }
+            //Microphone = Micros.FirstOrDefault();
+            executorService = Executors.NewSingleThreadExecutor();
+
+            initiated = true;
+            if (cameraView != null)
+            {
+                cameraView.Cameras.Clear();
+                foreach (var micro in Micros) cameraView.Microphones.Add(micro);
+                foreach (var cam in Cameras) cameraView.Cameras.Add(cam);
+                cameraView.RefreshDevices();
+            }
+        }
+    }
+
+    public async Task<CameraResult> StartRecordingAsync(string file)
+    {
+        var result = CameraResult.Success;
+        if (initiated && !recording)
+        {
+            if (await CameraView.RequestPermissions(true, true))
+            {
+                if (started) StopCamera();
+                if (Camera != null)
+                {
+                    CameraCharacteristics characteristics = cameraManager.GetCameraCharacteristics(Camera.DeviceId);
+
+                    StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
+                    videoSize = ChooseVideoSize(map.GetOutputSizes(Class.FromType(typeof(ImageReader))));
+                    AdjustAspectRatio(videoSize.Width, videoSize.Height);
+
+                    recording = true;
+
+                    if (OperatingSystem.IsAndroidVersionAtLeast(31))
+                        mediaRecorder = new MediaRecorder(context);
+                    else
+                        mediaRecorder = new MediaRecorder();
+                    audioManager.Mode = Mode.Normal;
+                    mediaRecorder.SetAudioSource(AudioSource.Mic);
+                    mediaRecorder.SetVideoSource(VideoSource.Surface);
+                    mediaRecorder.SetOutputFormat(OutputFormat.Mpeg4);
+                    mediaRecorder.SetOutputFile(file);
+                    mediaRecorder.SetVideoEncodingBitRate(10000000);
+                    mediaRecorder.SetVideoFrameRate(30);
+                    mediaRecorder.SetVideoSize(videoSize.Width, videoSize.Height);
+                    mediaRecorder.SetVideoEncoder(VideoEncoder.H264);
+                    mediaRecorder.SetAudioEncoder(AudioEncoder.Aac);
+                    int rotation = (int)((IWindowManager)context.GetSystemService(Context.WindowService)).DefaultDisplay.Rotation;
+                    int orientation = ORIENTATIONS.Get(rotation);
+                    mediaRecorder.SetOrientationHint(orientation);
+                    mediaRecorder.Prepare();
+
+                    cameraManager.OpenCamera(Camera.DeviceId, executorService, stateListener);
+                    started = true;
+                }
+                else
+                    result = CameraResult.NoCameraSelected;
             }
+            else
+                result = CameraResult.AccessDenied;
         }
+        else
+            result = CameraResult.NotInitiated;
+
+        return result;
     }
 
+    private void StartPreview()
+    {
+        while (textureView.SurfaceTexture == null) Thread.Sleep(100);
+        SurfaceTexture texture = textureView.SurfaceTexture;
+        texture.SetDefaultBufferSize(videoSize.Width, videoSize.Height);
+        previewBuilder = cameraDevice.CreateCaptureRequest(recording ? CameraTemplate.Record : CameraTemplate.Preview);
+        var surfaces = new List<OutputConfiguration>();
+        var previewSurface = new Surface(texture);
+        surfaces.Add(new OutputConfiguration(previewSurface));
+        previewBuilder.AddTarget(previewSurface);
+        if (mediaRecorder != null)
+        {
+            surfaces.Add(new OutputConfiguration(mediaRecorder.Surface));
+            previewBuilder.AddTarget(mediaRecorder.Surface);
+        }
+
+        SessionConfiguration config = new((int)SessionType.Regular,surfaces,executorService, new PreviewCaptureStateCallback(this));
+        cameraDevice.CreateCaptureSession(config);
+    }
+    public void UpdatePreview()
+    {
+        if (null == cameraDevice)
+            return;
+
+        try
+        {
+            previewBuilder.Set(CaptureRequest.ControlMode, Java.Lang.Integer.ValueOf((int)ControlMode.Auto));
+            previewSession.SetRepeatingRequest(previewBuilder.Build(), null, null);
+            if (recording) mediaRecorder?.Start();
+        }
+        catch (CameraAccessException e)
+        {
+            e.PrintStackTrace();
+        }
+    }
     public async Task<CameraResult> StartCameraAsync()
     {
-        CameraResult result = CameraResult.Success;
+        var result = CameraResult.Success;
         if (initiated)
         {
-            previewView.LayoutParameters = new LayoutParams { Width = Width, Height = Height };
-            if (started) StopCamera();
-            if (await RequestPermissions())
+            if (await CameraView.RequestPermissions())
             {
-                if (Camera != null && cameraProvider != null)
+                if (started) StopCamera();
+                if (Camera != null)
                 {
-                    try
-                    {
-                        if (previewView.ScaleX == -1)
-                            SetImplementationMode(PreviewView.ImplementationMode.Compatible);
-                        else
-                            SetImplementationMode(PreviewView.ImplementationMode.Performance);
-                        CameraSelector cameraSelector = InternalCameras.First(c => c.CameraId == Camera.DeviceId).CameraSelector;
-                        frames = 0;
-                        
-                        if (Context is AndroidX.Lifecycle.ILifecycleOwner lifecycleOwner)
-                            camera = cameraProvider.BindToLifecycle(lifecycleOwner, cameraSelector, cameraPreview, imageAnalyzer);
-                        else if (Platform.CurrentActivity is AndroidX.Lifecycle.ILifecycleOwner maLifecycleOwner)
-                            camera = cameraProvider.BindToLifecycle(maLifecycleOwner, cameraSelector, cameraPreview, imageAnalyzer);
-                        
-                        UpdateTorch();
-                        UpdateMirroredImage();
-                        SetZoomFactor(cameraView.ZoomFactor);
-                        started = true;
-                    }
-                    catch
-                    {
-                        result = CameraResult.AccessError;
-                    }
+                    CameraCharacteristics characteristics = cameraManager.GetCameraCharacteristics(Camera.DeviceId);
+
+                    StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
+                    videoSize = ChooseVideoSize(map.GetOutputSizes(Class.FromType(typeof(ImageReader))));
+                    AdjustAspectRatio(videoSize.Width, videoSize.Height);
+                    cameraManager.OpenCamera(Camera.DeviceId, executorService, stateListener);
+                    timer.Start();
+                    started = true;
                 }
                 else
-                    result = CameraResult.AccessError;
+                    result = CameraResult.NoCameraSelected;
             }
             else
                 result = CameraResult.AccessDenied;
-        }else
+        }
+        else
             result = CameraResult.NotInitiated;
+
         return result;
     }
+    public Task<CameraResult> StopRecordingAsync()
+    {
+        recording = false;
+        return StartCameraAsync();
+    }
+
     public CameraResult StopCamera()
     {
         CameraResult result = CameraResult.Success;
         if (initiated)
         {
-            MainThread.InvokeOnMainThreadAsync(() =>
-            {
-                try
-                {
-                    cameraProvider?.UnbindAll();
-                    camera?.Dispose();
-                }
-                catch (System.Exception)
-                {
-                    result = CameraResult.AccessError;
-                }
-            }).Wait();
+            timer.Stop();
+            mediaRecorder?.Stop();
+            mediaRecorder?.Dispose();
+            previewSession?.StopRepeating();
+            cameraDevice?.Close();
+            previewSession?.Dispose();
+            cameraDevice?.Dispose();
+            backgroundThread?.Quit();
+            backgroundHandler?.Dispose();
+            backgroundThread?.Dispose();
+            backgroundThread = null;
+            backgroundHandler = null;
+            previewSession = null;
+            cameraDevice = null;
+            previewBuilder = null;
+            mediaRecorder = null;
             started = false;
+            recording = false;
         }
         else
             result = CameraResult.NotInitiated;
@@ -199,26 +265,23 @@ public CameraResult StopCamera()
     public void DisposeControl()
     {
         if (started) StopCamera();
-        cameraPreview?.Dispose();
         executorService?.Shutdown();
         executorService?.Dispose();
-        frameAnalyzer?.Dispose();
-        imageAnalyzer?.Dispose();
         RemoveAllViews();
-        previewView?.Dispose();
+        textureView?.Dispose();
+        timer.Dispose();
         Dispose();
     }
     private void ProccessQR()
     {
-        MainThread.BeginInvokeOnMainThread(() =>
+        Task.Run(() =>
         {
-            var bitmap = previewView.Bitmap;
-            Task.Run(() =>
+            Bitmap bitmap = TakeSnap();
+            if (bitmap != null)
             {
                 cameraView.DecodeBarcode(bitmap);
                 bitmap.Dispose();
-                GC.Collect();
-            });
+            }
         });
     }
     private void RefreshSnapShot()
@@ -226,13 +289,13 @@ private void RefreshSnapShot()
         cameraView.RefreshSnapshot(GetSnapShot(cameraView.AutoSnapShotFormat, true));
     }
 
-    private void FrameAnalyzer_FrameReady(object sender, EventArgs e)
+    private void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
     {
         if (!snapping && cameraView != null && cameraView.AutoSnapShotSeconds > 0 && (DateTime.Now - cameraView.lastSnapshot).TotalSeconds >= cameraView.AutoSnapShotSeconds)
         {
             Task.Run(() => RefreshSnapShot());
         }
-        else if(cameraView.BarCodeDetectionEnabled)
+        else if (cameraView.BarCodeDetectionEnabled)
         {
             frames++;
             if (frames >= cameraView.BarCodeDetectionFrameRate)
@@ -241,7 +304,31 @@ private void FrameAnalyzer_FrameReady(object sender, EventArgs e)
                 frames = 0;
             }
         }
+
+    }
+
+    private Bitmap TakeSnap()
+    {
+        Bitmap bitmap = null;
+        try
+        {
+            MainThread.InvokeOnMainThreadAsync(() => { bitmap = textureView.GetBitmap(null); bitmap = textureView.Bitmap; }).Wait();
+            if (bitmap != null)
+            {
+                bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, textureView.GetTransform(null), false);
+                bitmap = Bitmap.CreateBitmap(bitmap, Math.Abs(bitmap.Width - Width) / 2, Math.Abs(bitmap.Height - Height) / 2, Width, Height);
+                if (textureView.ScaleX == -1)
+                {
+                    Matrix matrix = new();
+                    matrix.PreScale(-1, 1);
+                    bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, false);
+                }
+            }
+        }
+        catch { }
+        return bitmap;
     }
+
     internal ImageSource GetSnapShot(ImageFormat imageFormat, bool auto = false)
     {
         ImageSource result = null;
@@ -249,50 +336,31 @@ internal ImageSource GetSnapShot(ImageFormat imageFormat, bool auto = false)
         if (started && !snapping)
         {
             snapping = true;
-            Bitmap bitmap = null;
-            float scale = 1;
-            MainThread.InvokeOnMainThreadAsync(() =>
-            {
-                bitmap = previewView.Bitmap;
-                scale = previewView.ScaleX;
-            }).Wait();
+            Bitmap bitmap = TakeSnap();
+
             if (bitmap != null)
             {
-                try
+                var iformat = imageFormat switch
                 {
-                    if (scale == -1)
-                    {
-                        Matrix matrix = new();
-                        matrix.PreScale(-1, 1);
-                        bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, false);
-                    }
-
-                    var iformat = imageFormat switch
-                    {
-                        ImageFormat.JPEG => Bitmap.CompressFormat.Jpeg,
-                        _ => Bitmap.CompressFormat.Png
-                    };
-                    MemoryStream stream = new();
-                    bitmap.Compress(iformat, 100, stream);
-                    stream.Position = 0;
-                    if (auto)
-                    {
-                        if (cameraView.AutoSnapShotAsImageSource)
-                            result = ImageSource.FromStream(() => stream);
-                        cameraView.SnapShotStream?.Dispose();
-                        cameraView.SnapShotStream = stream;
-                    }
-                    else
-                        result = ImageSource.FromStream(() => stream);
-                    bitmap.Dispose();
-                }
-                catch
+                    ImageFormat.JPEG => Bitmap.CompressFormat.Jpeg,
+                    _ => Bitmap.CompressFormat.Png
+                };
+                MemoryStream stream = new();
+                bitmap.Compress(iformat, 100, stream);
+                stream.Position = 0;
+                if (auto)
                 {
+                    if (cameraView.AutoSnapShotAsImageSource)
+                        result = ImageSource.FromStream(() => stream);
+                    cameraView.SnapShotStream?.Dispose();
+                    cameraView.SnapShotStream = stream;
                 }
+                else
+                    result = ImageSource.FromStream(() => stream);
+                bitmap.Dispose();
             }
             snapping = false;
         }
-        GC.Collect();
         return result;
     }
 
@@ -300,108 +368,87 @@ public bool SaveSnapShot(ImageFormat imageFormat, string SnapFilePath)
     {
         bool result = true;
 
-        if (started)
+        if (started && !snapping)
         {
-            Bitmap bitmap = null;
-            float scale = 1;
-            MainThread.InvokeOnMainThreadAsync(() =>
-            {
-                bitmap = previewView.Bitmap;
-                scale = previewView.ScaleX;
-            }).Wait();
+            snapping = true;
+            Bitmap bitmap = TakeSnap();
             if (bitmap != null)
             {
-                try
-                {
-                    if (File.Exists(SnapFilePath)) File.Delete(SnapFilePath);
-                    if (scale == -1)
-                    {
-                        Matrix matrix = new();
-                        matrix.PreScale(-1, 1);
-                        bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, false);
-                    }
-
-                    var iformat = imageFormat switch
-                    {
-                        ImageFormat.JPEG => Bitmap.CompressFormat.Jpeg,
-                        _ => Bitmap.CompressFormat.Png
-                    };
-                    using FileStream stream = new(SnapFilePath, FileMode.OpenOrCreate);
-                    bitmap.Compress(iformat, 80, stream);
-                    stream.Close();
-                }
-                catch (System.Exception)
+                if (File.Exists(SnapFilePath)) File.Delete(SnapFilePath);
+                var iformat = imageFormat switch
                 {
-                    result = false;
-                }
+                    ImageFormat.JPEG => Bitmap.CompressFormat.Jpeg,
+                    _ => Bitmap.CompressFormat.Png
+                };
+                using FileStream stream = new(SnapFilePath, FileMode.OpenOrCreate);
+                bitmap.Compress(iformat, 80, stream);
+                stream.Close();
             }
-        }else
+            snapping = false;
+        }
+        else
             result = false;
 
-        GC.Collect();
         return result;
     }
-    private static async Task<bool> RequestPermissions()
-    {
-        var status = await Permissions.CheckStatusAsync<Permissions.Camera>();
-        if (status != PermissionStatus.Granted)
-        {
-            status = await Permissions.RequestAsync<Permissions.Camera>();
-            if (status != PermissionStatus.Granted) return false;
-        }
-        return true;
-    }
     public async void UpdateCamera()
     {
         if (cameraView != null && cameraView.Camera != null)
         {
-            if (started) StopCamera();
-            Camera = cameraView.Camera;
-            if (started) await StartCameraAsync();
+            if (started)
+            {
+                StopCamera();
+                Camera = cameraView.Camera;
+                await StartCameraAsync();
+            }else
+                Camera = cameraView.Camera;
         }
     }
     public void UpdateMirroredImage()
     {
-        if (cameraView != null)
+        if (cameraView != null && textureView != null)
         {
-            if (cameraView.MirroredImage)
-            {
-                previewView.ScaleX = -1;
-                SetImplementationMode(PreviewView.ImplementationMode.Compatible);
-            }
+            if (cameraView.MirroredImage) 
+                textureView.ScaleX = -1;
             else
-            {
-                previewView.ScaleX = 1;
-            }
+                textureView.ScaleX = 1;
         }
     }
     public void UpdateTorch()
     {
-        if (camera != null && cameraView != null)
+        if (Camera != null && Camera.HasFlashUnit)
         {
-            if (camera.CameraInfo.HasFlashUnit)
-                camera.CameraControl.EnableTorch(cameraView.TorchEnabled);
+            if (started)
+            {
+                previewBuilder.Set(CaptureRequest.ControlAeMode, (int)ControlAEMode.On);
+                previewBuilder.Set(CaptureRequest.FlashMode, cameraView.TorchEnabled ? (int)ControlAEMode.OnAutoFlash : (int)ControlAEMode.Off);
+                previewSession.SetRepeatingRequest(previewBuilder.Build(), null, null);
+            }
+            else if (initiated)
+                cameraManager.SetTorchMode(Camera.DeviceId, cameraView.TorchEnabled);
         }
     }
-
     public void UpdateFlashMode()
     {
-        if (camera != null && cameraView != null)
+        if (previewSession != null && previewBuilder != null && Camera != null && cameraView != null)
         {
             try
             {
-                if (camera.CameraInfo.HasFlashUnit)
+                if (Camera.HasFlashUnit)
                 {
                     switch (cameraView.FlashMode)
                     {
                         case FlashMode.Auto:
-                            camera.CameraControl.EnableTorch(true);
+                            previewBuilder.Set(CaptureRequest.ControlAeMode, (int)ControlAEMode.OnAutoFlash);
+                            previewSession.SetRepeatingRequest(previewBuilder.Build(), null, null);
                             break;
                         case FlashMode.Enabled:
-                            camera.CameraControl.EnableTorch(true);
+                            previewBuilder.Set(CaptureRequest.ControlAeMode, (int)ControlAEMode.On);
+                            previewSession.SetRepeatingRequest(previewBuilder.Build(), null, null);
                             break;
                         case FlashMode.Disabled:
-                            camera.CameraControl.EnableTorch(false);
+                            previewBuilder.Set(CaptureRequest.ControlAeMode, (int)ControlAEMode.Off);
+                            previewSession.SetRepeatingRequest(previewBuilder.Build(), null, null);
                             break;
                     }
                 }
@@ -413,30 +460,103 @@ public void UpdateFlashMode()
     }
     public void SetZoomFactor(float zoom)
     {
-        camera?.CameraControl.SetZoomRatio(Math.Max(MinZoomFactor, Math.Min(zoom, MaxZoomFactor)));
+        if (previewSession != null && previewBuilder != null && Camera != null)
+        {
+            if (OperatingSystem.IsAndroidVersionAtLeast(30))
+            {
+                previewBuilder.Set(CaptureRequest.ControlZoomRatio, Math.Max(Camera.MinZoomFactor, Math.Min(zoom, Camera.MaxZoomFactor)));
+                previewSession.SetRepeatingRequest(previewBuilder.Build(), null, null);
+            }
+        }
+    }
+
+    private Size ChooseVideoSize(Size[] choices)
+    {
+        Size result = choices[0];
+        int diference = 100000;
+        if (Width >= Height)
+        {
+            foreach (Size size in choices)
+            {
+                if (size.Height >= 1080 && size.Width >= Width && size.Width == size.Height * 4 / 3)
+                {
+                    int dif = Math.Abs(size.Width - Width) + Math.Abs(size.Height - Height);
+                    if (dif < diference) result = size;
+                    diference = dif;
+                }
+                else if (size.Width >= result.Width && result.Width < Width)
+                    result = size;
+            }
+        }
+        else
+        {
+            foreach (Size size in choices)
+            {
+                if (size.Height >= 1080 && size.Height >= Height && size.Width == size.Height * 4 / 3)
+                {
+                    int dif = Math.Abs(size.Width - Width) + Math.Abs(size.Height - Height);
+                    if (dif < diference) result = size;
+                    diference = dif;
+                }
+                else if (size.Height >= result.Height && result.Height < Height)
+                    result = size;
+            }
+        }
+        return result;
     }
-    private async void SetImplementationMode(PreviewView.ImplementationMode mode)
+    
+    private void AdjustAspectRatio(int videoWidth, int videoHeight)
     {
+        Matrix txform = new();
+        float centerX = Math.Max((videoWidth - Width) / 2, 0);
+        float centerY = Math.Max((videoHeight - Height) / 2, 0);
+        float scaleX = Width > Height ? 1 : (float)videoHeight / Height;
+        float scaleY = Height <= Width ? (float)videoWidth / Width : 1;
 
-        if (started && currentImplementationMode != mode)
+        txform.PostScale(scaleX, scaleY, centerX, centerY);
+        textureView.SetTransform(txform);
+    }    
+
+    private class MyCameraStateCallback : CameraDevice.StateCallback
+    {
+        private readonly MauiCameraView cameraView;
+        public MyCameraStateCallback(MauiCameraView camView)
         {
-            StopCamera();
-            previewView.SetImplementationMode(mode);
-            await StartCameraAsync();
-        }else
-            previewView.SetImplementationMode(mode);
+            cameraView = camView;
+        }
+        public override void OnOpened(CameraDevice camera)
+        {
+            cameraView.cameraDevice = camera;
+            cameraView.StartPreview();
+        }
 
-        currentImplementationMode = mode;
+        public override void OnDisconnected(CameraDevice camera)
+        {
+            camera.Close();
+            cameraView.cameraDevice = null;
+        }
+
+        public override void OnError(CameraDevice camera, CameraError error)
+        {
+            camera?.Close();
+            cameraView.cameraDevice = null;
+        }
     }
-    class ImageAnalyzer : Java.Lang.Object, ImageAnalysis.IAnalyzer
+    private class PreviewCaptureStateCallback : CameraCaptureSession.StateCallback
     {
-        public IImageProxy Image { get; private set; }
-        public event EventHandler FrameReady;
-        public void Analyze(IImageProxy image)
+        private readonly MauiCameraView cameraView;
+        public PreviewCaptureStateCallback(MauiCameraView camView)
+        {
+            cameraView = camView;
+        }
+        public override void OnConfigured(CameraCaptureSession session)
+        {
+            cameraView.previewSession = session;
+            cameraView.UpdatePreview();
+
+        }
+        public override void OnConfigureFailed(CameraCaptureSession session)
         {
-            Image = image;
-            FrameReady?.Invoke(this, EventArgs.Empty);
-            image.Close();
         }
     }
 }
diff --git a/Camera.MAUI/Platforms/Windows/MauiCameraView.cs b/Camera.MAUI/Platforms/Windows/MauiCameraView.cs
index bb6a337..00302b4 100644
--- a/Camera.MAUI/Platforms/Windows/MauiCameraView.cs
+++ b/Camera.MAUI/Platforms/Windows/MauiCameraView.cs
@@ -6,42 +6,30 @@
 using Windows.Graphics.Imaging;
 using Windows.Media.Devices;
 using Panel = Windows.Devices.Enumeration.Panel;
+using Windows.Media.MediaProperties;
 
 namespace Camera.MAUI.Platforms.Windows;
 
 public sealed partial class MauiCameraView : UserControl, IDisposable
 {
     private readonly List<CameraInfo> Cameras = new();
-    public CameraInfo Camera { get; set; }
-    public float MinZoomFactor
-    {
-        get
-        {
-            if (frameSource != null && frameSource.Controller.VideoDeviceController.ZoomControl.Supported)
-                return frameSource.Controller.VideoDeviceController.ZoomControl.Min;
-            else
-                return 1f;
-        }
-    }
-    public float MaxZoomFactor { get
-        {
-            if (frameSource != null && frameSource.Controller.VideoDeviceController.ZoomControl.Supported)
-                return frameSource.Controller.VideoDeviceController.ZoomControl.Max;
-            else
-                return 1f;
-        } 
-    }
+    private readonly List<MicrophoneInfo> Micros = new();
+    private CameraInfo Camera { get; set; }
+    private MicrophoneInfo Microphone { get; set; }
 
     private readonly MediaPlayerElement mediaElement;
     private MediaCapture mediaCapture;
     private MediaFrameSource frameSource;
     private MediaFrameReader frameReader;
+    private LowLagMediaRecording mediaRecording;
     private List<MediaFrameSourceGroup> sGroups;
     private bool snapping = false;
     private bool started = false;
     private Microsoft.UI.Xaml.FlowDirection flowDirection = Microsoft.UI.Xaml.FlowDirection.LeftToRight;
     private int frames = 0;
     private bool initiated = false;
+    private bool recording = false;
+    private FileStream recordStream;
 
     private readonly CameraView cameraView;
     public MauiCameraView(CameraView cameraView)
@@ -59,9 +47,13 @@ public async void UpdateCamera()
     {
         if (cameraView != null && cameraView.Camera != null)
         {
-            if(started) await StopCameraAsync();
-            Camera = cameraView.Camera;
-            if (started) await StartCameraAsync();
+            if (started)
+            {
+                await StopCameraAsync();
+                Camera = cameraView.Camera;
+                await StartCameraAsync();
+            }else
+                Camera = cameraView.Camera;
         }
     }
     public void UpdateMirroredImage()
@@ -77,9 +69,9 @@ public void UpdateMirroredImage()
     }
     public void SetZoomFactor(float zoom)
     {
-        if (frameSource != null && frameSource.Controller.VideoDeviceController.ZoomControl.Supported)
+        if (Camera != null && frameSource != null && frameSource.Controller.VideoDeviceController.ZoomControl.Supported)
         {
-            frameSource.Controller.VideoDeviceController.ZoomControl.Value = Math.Max(MinZoomFactor, Math.Min(zoom, MaxZoomFactor));
+            frameSource.Controller.VideoDeviceController.ZoomControl.Value = Math.Max(Camera.MinZoomFactor, Math.Min(zoom, Camera.MaxZoomFactor));
         }
     }
     public void UpdateFlashMode()
@@ -139,6 +131,7 @@ private void InitDevices()
                             };
                     }
                     mediaCapture = new MediaCapture();
+                    
                     mediaCapture.InitializeAsync(new MediaCaptureInitializationSettings
                     {
                         SourceGroup = s,
@@ -157,14 +150,21 @@ private void InitDevices()
                         MaxZoomFactor = frameSource.Controller.VideoDeviceController.ZoomControl.Supported ? frameSource.Controller.VideoDeviceController.ZoomControl.Max : 1f
                     });
                 }
-
                 Camera = Cameras.FirstOrDefault();
+
+                var aDevices = DeviceInformation.FindAllAsync(DeviceClass.AudioCapture).GetAwaiter().GetResult();
+                foreach (var device in aDevices)
+                    Micros.Add(new MicrophoneInfo { Name = device.Name, DeviceId = device.Id });
+                Microphone = Micros.FirstOrDefault();
+
+                initiated = true;
                 if (cameraView != null)
                 {
                     cameraView.Cameras.Clear();
+                    foreach (var micro in Micros) cameraView.Microphones.Add(micro);
                     foreach (var cam in Cameras) cameraView.Cameras.Add(cam);
+                    cameraView.RefreshDevices();
                 }
-                initiated = true;
             }
             catch
             {
@@ -172,6 +172,67 @@ private void InitDevices()
             }
         }
     }
+    public async Task<CameraResult> StartRecordingAsync(string file)
+    {
+        CameraResult result = CameraResult.Success;
+
+        if (initiated)
+        {
+            if (started) await StopCameraAsync();
+            if (Camera != null && Microphone != null)
+            {
+                started = true;
+
+                mediaCapture = new MediaCapture();
+                try
+                {
+                    await mediaCapture.InitializeAsync(new MediaCaptureInitializationSettings
+                    {
+                        VideoDeviceId = Camera.DeviceId,
+                        MemoryPreference = MediaCaptureMemoryPreference.Cpu,
+                        AudioDeviceId = Microphone.DeviceId
+                    });
+
+                    MediaEncodingProfile profile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto);
+                    recordStream = new(file, FileMode.Create);
+                    mediaRecording = await mediaCapture.PrepareLowLagRecordToStreamAsync(profile, recordStream.AsRandomAccessStream());
+
+                    frameSource = mediaCapture.FrameSources.FirstOrDefault(source => source.Value.Info.MediaStreamType == MediaStreamType.VideoRecord
+                                                                                  && source.Value.Info.SourceKind == MediaFrameSourceKind.Color).Value;
+                    if (frameSource != null)
+                    {
+                        UpdateTorch();
+                        SetZoomFactor(cameraView.ZoomFactor);
+
+                        mediaElement.AutoPlay = true;
+                        mediaElement.Source = MediaSource.CreateFromMediaFrameSource(frameSource);
+                        await mediaRecording.StartAsync();
+                        recording = true;
+                    }
+                    else
+                        result = CameraResult.NoVideoFormatsAvailable;
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    result = CameraResult.AccessDenied;
+                }
+                catch (Exception)
+                {
+                    result = CameraResult.AccessError;
+                }
+            }
+            else
+                result = Camera == null ? CameraResult.NoCameraSelected : CameraResult.NoMicrophoneSelected;
+        }
+        else
+            result = CameraResult.NotInitiated;
+
+        return result;
+    }
+    public async Task<CameraResult> StopRecordingAsync()
+    {
+        return await StartCameraAsync();
+    }
     public async Task<CameraResult> StartCameraAsync()
     {
         CameraResult result = CameraResult.Success;
@@ -306,6 +367,13 @@ public async Task<CameraResult> StopCameraAsync()
         {
             try
             {
+                if (recording && mediaRecording != null)
+                {
+                    await mediaRecording.StopAsync();
+                    recording = false;
+                    recordStream?.Close();
+                    recordStream?.Dispose();
+                }
                 if (frameReader != null)
                 {
                     await frameReader.StopAsync();
diff --git a/MauiCameraView.backup b/MauiCameraView.backup
new file mode 100644
index 0000000..560b6d1
--- /dev/null
+++ b/MauiCameraView.backup
@@ -0,0 +1,980 @@
+using Android.Content;
+using Android.Widget;
+using AndroidX.Camera.View;
+using AndroidX.Camera.Video;
+using AndroidX.Camera.Lifecycle;
+using AndroidX.Camera.Core;
+using Java.Util.Concurrent;
+using Android.Graphics;
+using AndroidX.Camera.Core.Impl;
+using AndroidX.Camera.Camera2.InterOp;
+using CameraCharacteristics = Android.Hardware.Camera2.CameraCharacteristics;
+using Android.Hardware.Camera2;
+using Android.Media;
+using Android.Provider;
+using VideoCapture = AndroidX.Camera.Video.VideoCapture;
+using Android.Runtime;
+using Android.Views;
+using Android.Util;
+using Android.OS;
+using static AndroidX.Camera.Core.Internal.CameraUseCaseAdapter;
+using Android.Hardware.Camera2.Params;
+using Android.Renderscripts;
+using Android.Gestures;
+using Size = Android.Util.Size;
+using Android.Nfc;
+using AndroidX.Camera.Core.Impl.Utils;
+using Java.Util;
+using Android.Hardware.Lights;
+using Microsoft.Maui.ApplicationModel;
+using static Android.Icu.Text.ListFormatter;
+using Class = Java.Lang.Class;
+using RectF = Android.Graphics.RectF;
+using Cam = Android.Hardware.Camera;
+using static Java.Text.Normalizer;
+
+namespace Camera.MAUI.Platforms.Android;
+
+internal class MauiCameraView: FrameLayout
+{
+    public CameraInfo Camera { get; set; }
+    public float MinZoomFactor
+    {
+        get
+        {
+            if (camera != null)
+                return (camera.CameraInfo.ZoomState.Value as IZoomState).MinZoomRatio;
+            else
+                return 1f;
+        }
+    }
+    public float MaxZoomFactor
+    {
+        get
+        {
+            if (camera != null)
+                return (camera.CameraInfo.ZoomState.Value as IZoomState).MaxZoomRatio;
+            else
+                return 1f;
+        }
+    }
+    private record InternalCameraInfo
+    {
+        public CameraSelector CameraSelector { get; set; }
+        public string CameraId { get; set; }
+    }
+    private readonly List<CameraInfo> Cameras = new();
+    private readonly List<InternalCameraInfo> InternalCameras = new();
+    private readonly CameraView cameraView;
+    private readonly PreviewView previewView;
+    private IExecutorService executorService;
+    private ImageAnalysis imageAnalyzer;
+    private ImageAnalyzer frameAnalyzer;
+    private ProcessCameraProvider cameraProvider;
+    private ICamera camera;
+    private Preview cameraPreview;
+    private bool started = false;
+    private PreviewView.ImplementationMode currentImplementationMode = PreviewView.ImplementationMode.Performance;
+    private int frames = 0;
+    private bool initiated = false;
+    private bool snapping = false;
+    private Context context;
+    private Recording recording;
+    private VideoCapture capture;
+
+    private readonly TextureView textureView;
+    public CameraCaptureSession previewSession;
+    public MediaRecorder mediaRecorder;
+    private MySurfaceTextureListener surfaceTextureListener;
+    public CaptureRequest.Builder builder;
+    private CaptureRequest.Builder previewBuilder;
+    private HandlerThread backgroundThread;
+    private Handler backgroundHandler;
+    private CameraDevice cameraDevice;
+    private MyCameraStateCallback stateListener;
+    private Size videoSize;
+    private Size previewSize;
+
+    private CameraManager manager;
+
+
+    public MauiCameraView(Context context, CameraView cameraView) : base(context)
+    {
+        this.context = context;
+        this.cameraView = cameraView;
+        previewView = new PreviewView(context);
+        previewView.SetScaleType(PreviewView.ScaleType.FillCenter);
+        //AddView(previewView);
+
+        textureView = new(context);
+        
+        //surfaceTextureListener = new MySurfaceTextureListener();
+        //textureView.SurfaceTextureListener = surfaceTextureListener;
+        stateListener = new MyCameraStateCallback(this);
+        backgroundThread = new HandlerThread("CameraBackground");
+        backgroundThread.Start();
+        backgroundHandler = new Handler(backgroundThread.Looper);
+        AddView(textureView);
+        InitDevices();
+    }
+
+    private void InitDevices()
+    {
+        if (!initiated)
+        {
+            manager = (CameraManager)context.GetSystemService(Context.CameraService);
+            foreach (var id in manager.GetCameraIdList())
+            {
+                var cameraInfo = new CameraInfo { DeviceId = id, MinZoomFactor = 1 };
+                var chars = manager.GetCameraCharacteristics(id);
+                if ((int)(chars.Get(CameraCharacteristics.LensFacing) as Java.Lang.Number) == (int)LensFacing.Back)
+                {
+                    cameraInfo.Name = "Back Camera";
+                    cameraInfo.Position = CameraPosition.Back;
+                }
+                else if ((int)(chars.Get(CameraCharacteristics.LensFacing) as Java.Lang.Number) == (int)LensFacing.Front)
+                {
+                    cameraInfo.Name = "Front Camera";
+                    cameraInfo.Position = CameraPosition.Front;
+                }
+                else
+                {
+                    cameraInfo.Name = "Camera " + id;
+                    cameraInfo.Position = CameraPosition.Unknow;
+                }
+                cameraInfo.MaxZoomFactor = (float)(chars.Get(CameraCharacteristics.ScalerAvailableMaxDigitalZoom) as Java.Lang.Number) * 10;
+                cameraInfo.HasFlashUnit = (bool)(chars.Get(CameraCharacteristics.FlashInfoAvailable) as Java.Lang.Boolean);
+                Cameras.Add(cameraInfo);
+            }
+            executorService = Executors.NewSingleThreadExecutor();
+
+            initiated = true;
+            if (cameraView != null)
+            {
+                cameraView.Cameras.Clear();
+                foreach (var cam in Cameras) cameraView.Cameras.Add(cam);
+                cameraView.RefreshCameras();
+            }
+        }
+    }
+
+    private void InitDevices_old()
+    {
+        if (!initiated)
+        {
+            try
+            {
+                var initCameraProvider = ProcessCameraProvider.GetInstance(Context);
+                cameraProvider = (ProcessCameraProvider)initCameraProvider.Get();
+                cameraPreview = new Preview.Builder().Build();
+                cameraPreview.SetSurfaceProvider(previewView.SurfaceProvider);
+                executorService = Executors.NewSingleThreadExecutor();
+                frameAnalyzer = new ImageAnalyzer();
+                frameAnalyzer.FrameReady += FrameAnalyzer_FrameReady;
+                imageAnalyzer = new ImageAnalysis.Builder().SetBackpressureStrategy(ImageAnalysis.StrategyKeepOnlyLatest).Build();
+                imageAnalyzer.SetAnalyzer(executorService, frameAnalyzer);
+
+                if (cameraProvider != null)
+                {
+                    foreach (var camInfo in cameraProvider.AvailableCameraInfos)
+                    {
+                        var c2cInfo = Camera2CameraInfo.From(camInfo);
+                        if ((int)(c2cInfo.GetCameraCharacteristic(CameraCharacteristics.LensFacing) as Java.Lang.Number) == (int)LensFacing.Back)
+                            Cameras.Add(new CameraInfo 
+                            { 
+                                Name = "Back Camera", DeviceId = c2cInfo.CameraId, Position = CameraPosition.Back,
+                                HasFlashUnit = camInfo.HasFlashUnit,
+                                MinZoomFactor = (camInfo.ZoomState.Value as IZoomState).MinZoomRatio,
+                                MaxZoomFactor = (camInfo.ZoomState.Value as IZoomState).MaxZoomRatio
+                            });
+                        else if ((int)(c2cInfo.GetCameraCharacteristic(CameraCharacteristics.LensFacing) as Java.Lang.Number) == (int)LensFacing.Front)
+                            Cameras.Add(new CameraInfo 
+                            { 
+                                Name = "Front Camera", DeviceId = c2cInfo.CameraId, Position = CameraPosition.Front,
+                                HasFlashUnit = camInfo.HasFlashUnit,
+                                MinZoomFactor = (camInfo.ZoomState.Value as IZoomState).MinZoomRatio,
+                                MaxZoomFactor = (camInfo.ZoomState.Value as IZoomState).MaxZoomRatio
+                            });
+                        else
+                        {
+                            Cameras.Add(new CameraInfo 
+                            {
+                                Name = "Camera " + c2cInfo.CameraId, DeviceId = c2cInfo.CameraId, Position = CameraPosition.Unknow,
+                                HasFlashUnit = camInfo.HasFlashUnit,
+                                MinZoomFactor = (camInfo.ZoomState.Value as IZoomState).MinZoomRatio,
+                                MaxZoomFactor = (camInfo.ZoomState.Value as IZoomState).MaxZoomRatio
+                            });
+                        }
+                        InternalCameras.Add(new InternalCameraInfo { CameraSelector = camInfo.CameraSelector, CameraId = c2cInfo.CameraId });
+                    }
+                    Camera = Cameras.FirstOrDefault();
+                    MainThread.InvokeOnMainThreadAsync(() =>
+                    {
+                        try
+                        {
+                            cameraProvider?.UnbindAll();
+                        }
+                        catch{}
+                    }).Wait();
+                    initiated = true;
+                    if (cameraView != null)
+                    {
+                        cameraView.Cameras.Clear();
+                        foreach (var cam in Cameras) cameraView.Cameras.Add(cam);
+                        cameraView.RefreshCameras();
+                    }
+                }
+            }
+            catch
+            {
+            }
+        }
+    }
+    public async Task<CameraResult> StartRecordingAsync(string file)
+    {
+        var result = CameraResult.Success;
+        //var manager = (CameraManager)context.GetSystemService(Context.CameraService);
+
+        CameraCharacteristics characteristics = manager.GetCameraCharacteristics(Camera.DeviceId);
+        StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
+        //videoSize = ChooseVideoSize(map.GetOutputSizes(Class.FromType(typeof(MediaRecorder))));
+        //videoSize = ChooseVideoSize(map.GetOutputSizes(Class.FromType(typeof(ImageReader))));
+        //previewSize = ChooseOptimalSize(map.GetOutputSizes(Class.FromType(typeof(MediaRecorder))), Width, Height, videoSize);
+        previewSize = new Size(videoSize.Width, videoSize.Height);
+        //textureView.SetAspectRatio(previewSize.Width, previewSize.Height);
+        //textureView.SetAspectRatio(640, 480);
+        configureTransform(Width, Height);
+        //AdjustAspectRatioFit(videoSize.Width, videoSize.Height);
+        //AdjustAspectRatioFit(1440, 1080);
+        
+        //manager.OpenCamera(Camera.DeviceId, stateListener, null);
+        manager.OpenCamera(Camera.DeviceId, executorService, stateListener);
+        //recorder.SetAudioSource(AudioSource.Mic);
+        //recorder.SetInputSurface(cameraPreview.sur);
+
+        return result;
+    }
+
+    private void startPreview()
+    {
+        SurfaceTexture texture = textureView.SurfaceTexture;
+        //texture.SetDefaultBufferSize(previewSize.Width, previewSize.Height);
+        //texture.SetDefaultBufferSize(1920, 1080);
+        texture.SetDefaultBufferSize(videoSize.Width, videoSize.Height);
+        //textureView.LayoutParameters = new LayoutParams { Width = Width, Height = Height };
+        //textureView.SetAspectRatio(Width, Height);
+        //var matrix = textureView.GetTransform(null);
+        /*
+        MainThread.InvokeOnMainThreadAsync(() =>
+        {
+            textureView.LayoutParameters = new LayoutParams { Width = Width, Height = Height };
+            textureView.SetForegroundGravity(GravityFlags.Center);
+            textureView.Holder.SetFixedSize(Width, Height);
+        }).Wait();
+        */
+        previewBuilder = cameraDevice.CreateCaptureRequest(CameraTemplate.Preview);
+        var surfaces = new List<OutputConfiguration>();
+        var previewSurface = new Surface(texture);
+        //var previewSurface = textureView.Holder.Surface;
+        var oconfig = new OutputConfiguration(previewSurface);
+        surfaces.Add(oconfig);
+        
+        previewBuilder.AddTarget(previewSurface);
+
+        SessionConfiguration config = new SessionConfiguration((int)SessionType.Regular,surfaces,executorService, new PreviewCaptureStateCallback(this));
+        //cameraDevice.CreateCaptureSession(surfaces, new PreviewCaptureStateCallback(this), backgroundHandler);
+        cameraDevice.CreateCaptureSession(config);
+    }
+    public void updatePreview()
+    {
+        if (null == cameraDevice)
+            return;
+
+        try
+        {
+            previewBuilder.Set(CaptureRequest.ControlMode, Java.Lang.Integer.ValueOf((int)ControlMode.Auto));
+            previewSession.SetRepeatingRequest(previewBuilder.Build(), null, null);
+        }
+        catch (CameraAccessException e)
+        {
+            e.PrintStackTrace();
+        }
+    }
+    public async Task<CameraResult> StartCameraAsync()
+    {
+        var result = CameraResult.Success;
+        if (initiated)
+        {
+            //textureView.LayoutParameters = new LayoutParams { Width = 1920, Height = 1080 };
+            if (await RequestPermissions())
+            {
+                if (started) StopCamera();
+                if (Camera != null)
+                {
+                    CameraCharacteristics characteristics = manager.GetCameraCharacteristics(Camera.DeviceId);
+
+                    StreamConfigurationMap map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap);
+                    videoSize = ChooseVideoSize(map.GetOutputSizes(Class.FromType(typeof(MediaRecorder))));
+                    previewSize = new Size(Width, Height);
+                    //AdjustAspectRatioFit(videoSize.Width, videoSize.Height);
+
+                    //previewSize = new Size(Width, Height);
+                    //AdjustAspectRatioFit(2304, 1728);
+                    videoSize = ChooseVideoSize(map.GetOutputSizes(Class.FromType(typeof(ImageReader))));
+                    //AdjustAspectRatioFit(1920, 1080);
+                    AdjustAspectRatioFit(videoSize.Width, videoSize.Height);
+                    manager.OpenCamera(Camera.DeviceId, executorService, stateListener);
+                    started = true;
+
+                    //textureView.LayoutParameters = new LayoutParams { Width = Width, Height = Height };
+                }
+                else
+                    result = CameraResult.NoCameraSelected;
+            }
+            else
+                result = CameraResult.AccessDenied;
+        }
+        else
+            result = CameraResult.NotInitiated;
+
+        return result;
+    }
+    public async Task<CameraResult> StartCameraAsync_old()
+    {
+        var result = CameraResult.Success;
+        if (initiated)
+        {
+            //previewView.LayoutParameters = new LayoutParams { Width = Width, Height = Height };
+            if (started) StopCamera();
+            if (await RequestPermissions())
+            {
+                if (Camera != null && cameraProvider != null)
+                {
+                    try
+                    {
+                        if (previewView.ScaleX == -1)
+                            SetImplementationMode(PreviewView.ImplementationMode.Compatible);
+                        else
+                            SetImplementationMode(PreviewView.ImplementationMode.Performance);
+                        CameraSelector cameraSelector = InternalCameras.First(c => c.CameraId == Camera.DeviceId).CameraSelector;
+                        frames = 0;
+                        var recorderBuilder = new Recorder.Builder();
+                        var recorder = recorderBuilder.SetQualitySelector(QualitySelector.From(Quality.Hd)).Build();
+
+                        ContentValues contentValues = new ContentValues();
+                        //contentValues.Put(MediaStore.Video.Media.InternalContentUri.Path)
+
+                        string filename = System.IO.Path.Combine(FileSystem.Current.CacheDirectory, "temp.mp4");
+                        var file = new Java.IO.File(filename);
+
+                        IntPtr classPtr = JNIEnv.FindClass("androidx/camera/video/FileOutputOptions$Builder");
+                        IntPtr constructorPtr = JNIEnv.GetMethodID(classPtr, "<init>", "(Ljava/io/File;)V");
+                        IntPtr builderPtr = JNIEnv.NewObject(classPtr, constructorPtr, new JValue(file));
+                        IntPtr buildPtr = JNIEnv.GetMethodID(classPtr, "build", "()Landroidx/camera/video/FileOutputOptions;");
+                        IntPtr fileOutputOptionsPtr = JNIEnv.CallNonvirtualObjectMethod(builderPtr, classPtr, buildPtr);
+                        var fileOutputOptions = new Java.Lang.Object(fileOutputOptionsPtr, JniHandleOwnership.TransferLocalRef)
+                            .JavaCast<FileOutputOptions>();
+
+                        capture = VideoCapture.WithOutput(recorder);
+
+                        if (Context is AndroidX.Lifecycle.ILifecycleOwner lifecycleOwner)
+                            camera = cameraProvider.BindToLifecycle(lifecycleOwner, cameraSelector, cameraPreview, capture);//imageAnalyzer, capture);
+                        else if (Platform.CurrentActivity is AndroidX.Lifecycle.ILifecycleOwner maLifecycleOwner)
+                            camera = cameraProvider.BindToLifecycle(maLifecycleOwner, cameraSelector, cameraPreview, capture);//imageAnalyzer, capture);
+
+                        recorder = capture.Output as Recorder;
+                        recording = recorder.PrepareRecording(context, fileOutputOptions).WithAudioEnabled().Start(executorService, new RecordConsumer());
+                        UpdateTorch();
+                        UpdateMirroredImage();
+                        SetZoomFactor(cameraView.ZoomFactor);
+                        started = true;
+                    }
+                    catch
+                    {
+                        result = CameraResult.AccessError;
+                    }
+                }
+                else
+                    result = CameraResult.AccessError;
+            }
+            else
+                result = CameraResult.AccessDenied;
+        }else
+            result = CameraResult.NotInitiated;
+        return result;
+    }
+    public CameraResult StopCamera()
+    {
+        CameraResult result = CameraResult.Success;
+        if (initiated)
+        {
+            previewSession?.StopRepeating();
+            cameraDevice?.Close();
+            previewSession?.Dispose();
+            cameraDevice?.Dispose();
+            started = false;
+        }
+        else
+            result = CameraResult.NotInitiated;
+        return result;
+    }
+    public CameraResult StopCamera_old()
+    {
+        CameraResult result = CameraResult.Success;
+        if (initiated)
+        {
+            MainThread.InvokeOnMainThreadAsync(() =>
+            {
+                try
+                {
+                    recording?.Stop();
+                    cameraProvider?.UnbindAll();
+                    camera?.Dispose();
+                }
+                catch (System.Exception)
+                {
+                    result = CameraResult.AccessError;
+                }
+            }).Wait();
+            started = false;
+        }
+        else
+            result = CameraResult.NotInitiated;
+        return result;
+    }
+    public void DisposeControl()
+    {
+        if (started) StopCamera();
+        cameraPreview?.Dispose();
+        executorService?.Shutdown();
+        executorService?.Dispose();
+        frameAnalyzer?.Dispose();
+        imageAnalyzer?.Dispose();
+        RemoveAllViews();
+        previewView?.Dispose();
+        Dispose();
+    }
+    private void ProccessQR()
+    {
+        MainThread.BeginInvokeOnMainThread(() =>
+        {
+            var bitmap = previewView.Bitmap;
+            Task.Run(() =>
+            {
+                cameraView.DecodeBarcode(bitmap);
+                bitmap.Dispose();
+                GC.Collect();
+            });
+        });
+    }
+    private void RefreshSnapShot()
+    {
+        cameraView.RefreshSnapshot(GetSnapShot(cameraView.AutoSnapShotFormat, true));
+    }
+
+    private void FrameAnalyzer_FrameReady(object sender, EventArgs e)
+    {
+        if (!snapping && cameraView != null && cameraView.AutoSnapShotSeconds > 0 && (DateTime.Now - cameraView.lastSnapshot).TotalSeconds >= cameraView.AutoSnapShotSeconds)
+        {
+            Task.Run(() => RefreshSnapShot());
+        }
+        else if(cameraView.BarCodeDetectionEnabled)
+        {
+            frames++;
+            if (frames >= cameraView.BarCodeDetectionFrameRate)
+            {
+                ProccessQR();
+                frames = 0;
+            }
+        }
+    }
+    internal ImageSource GetSnapShot(ImageFormat imageFormat, bool auto = false)
+    {
+        ImageSource result = null;
+
+        if (started && !snapping)
+        {
+            snapping = true;
+            Bitmap bitmap = null;
+            float scale = 1;
+            MainThread.InvokeOnMainThreadAsync(() =>
+            {
+                //bitmap = previewView.Bitmap;
+                //scale = previewView.ScaleX;
+                bitmap = textureView.Bitmap;
+                //bitmap = Bitmap.CreateBitmap(Width, Height, Bitmap.Config.Argb8888);
+                //Canvas canvas = new Canvas(bitmap);
+                //textureView.Draw(canvas);
+                //scale = textureView.ScaleX;
+            }).Wait();
+            if (bitmap != null)
+            {
+                try
+                {
+                    bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, textureView.GetTransform(null), false);
+                    bitmap = Bitmap.CreateBitmap(bitmap, Math.Abs(bitmap.Width - Width) / 2, Math.Abs(bitmap.Height - Height) / 2, Width, Height);
+                    //bitmap = ApplyTransform(bitmap);
+                    /*
+                    if (scale == -1)
+                    {
+                        Matrix matrix = new();
+                        matrix.PreScale(-1, 1);
+                        bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, textureView.GetTransform(null), false);
+                    }
+                    */
+                    var iformat = imageFormat switch
+                    {
+                        ImageFormat.JPEG => Bitmap.CompressFormat.Jpeg,
+                        _ => Bitmap.CompressFormat.Png
+                    };
+                    MemoryStream stream = new();
+                    bitmap.Compress(iformat, 100, stream);
+                    stream.Position = 0;
+                    if (auto)
+                    {
+                        if (cameraView.AutoSnapShotAsImageSource)
+                            result = ImageSource.FromStream(() => stream);
+                        cameraView.SnapShotStream?.Dispose();
+                        cameraView.SnapShotStream = stream;
+                    }
+                    else
+                        result = ImageSource.FromStream(() => stream);
+                    bitmap.Dispose();
+                }
+                catch
+                {
+                }
+            }
+            snapping = false;
+        }
+        GC.Collect();
+        return result;
+    }
+
+    public bool SaveSnapShot(ImageFormat imageFormat, string SnapFilePath)
+    {
+        bool result = true;
+
+        if (started)
+        {
+            Bitmap bitmap = null;
+            float scale = 1;
+            MainThread.InvokeOnMainThreadAsync(() =>
+            {
+                bitmap = previewView.Bitmap;
+                scale = previewView.ScaleX;
+            }).Wait();
+            if (bitmap != null)
+            {
+                try
+                {
+                    if (File.Exists(SnapFilePath)) File.Delete(SnapFilePath);
+                    if (scale == -1)
+                    {
+                        Matrix matrix = new();
+                        matrix.PreScale(-1, 1);
+                        bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, false);
+                    }
+
+                    var iformat = imageFormat switch
+                    {
+                        ImageFormat.JPEG => Bitmap.CompressFormat.Jpeg,
+                        _ => Bitmap.CompressFormat.Png
+                    };
+                    using FileStream stream = new(SnapFilePath, FileMode.OpenOrCreate);
+                    bitmap.Compress(iformat, 80, stream);
+                    stream.Close();
+                }
+                catch (System.Exception)
+                {
+                    result = false;
+                }
+            }
+        }else
+            result = false;
+
+        GC.Collect();
+        return result;
+    }
+    private static async Task<bool> RequestPermissions()
+    {
+        var status = await Permissions.CheckStatusAsync<Permissions.Camera>();
+        if (status != PermissionStatus.Granted)
+        {
+            status = await Permissions.RequestAsync<Permissions.Camera>();
+            if (status != PermissionStatus.Granted) return false;
+        }
+        return true;
+    }
+    public async void UpdateCamera()
+    {
+        if (cameraView != null && cameraView.Camera != null)
+        {
+            if (started) StopCamera();
+            Camera = cameraView.Camera;
+            if (started) await StartCameraAsync();
+        }
+    }
+    public void UpdateMirroredImage()
+    {
+        if (cameraView != null)
+        {
+            if (cameraView.MirroredImage)
+            {
+                previewView.ScaleX = -1;
+                SetImplementationMode(PreviewView.ImplementationMode.Compatible);
+            }
+            else
+            {
+                previewView.ScaleX = 1;
+            }
+        }
+    }
+    public void UpdateTorch()
+    {
+        if (camera != null && cameraView != null)
+        {
+            if (camera.CameraInfo.HasFlashUnit)
+                camera.CameraControl.EnableTorch(cameraView.TorchEnabled);
+        }
+    }
+
+    public void UpdateFlashMode()
+    {
+        if (camera != null && cameraView != null)
+        {
+            try
+            {
+                if (camera.CameraInfo.HasFlashUnit)
+                {
+                    switch (cameraView.FlashMode)
+                    {
+                        case FlashMode.Auto:
+                            camera.CameraControl.EnableTorch(true);
+                            break;
+                        case FlashMode.Enabled:
+                            camera.CameraControl.EnableTorch(true);
+                            break;
+                        case FlashMode.Disabled:
+                            camera.CameraControl.EnableTorch(false);
+                            break;
+                    }
+                }
+            }
+            catch (System.Exception)
+            {
+            }
+        }
+    }
+    public void SetZoomFactor(float zoom)
+    {
+        camera?.CameraControl.SetZoomRatio(Math.Max(MinZoomFactor, Math.Min(zoom, MaxZoomFactor)));
+    }
+    private async void SetImplementationMode(PreviewView.ImplementationMode mode)
+    {
+
+        if (started && currentImplementationMode != mode)
+        {
+            StopCamera();
+            previewView.SetImplementationMode(mode);
+            await StartCameraAsync();
+        }else
+            previewView.SetImplementationMode(mode);
+
+        currentImplementationMode = mode;
+    }
+    private Size ChooseVideoSize(Size[] choices)
+    {
+        Size result = choices[0];
+        int diference = 100000;
+        if (Width >= Height)
+        {
+            foreach (Size size in choices)
+            {
+                //System.Diagnostics.Debug.WriteLine($"{size.Width}x{size.Height}");
+                if (size.Height >= 1080 && size.Width >= Width && size.Width == size.Height * 4 / 3)
+                {
+                    System.Diagnostics.Debug.WriteLine($"{size.Width}x{size.Height}");
+                    int dif = Math.Abs(size.Width - Width) + Math.Abs(size.Height - Height);
+                    if (dif < diference) result = size;
+                    diference = dif;
+                }
+                else if (size.Width >= result.Width && result.Width < Width)
+                    result = size;
+            }
+        }
+        else
+        {
+            foreach (Size size in choices)
+            {
+                if (size.Height >= 1080 && size.Height >= Height && size.Width == size.Height * 4 / 3)
+                {
+                    int dif = Math.Abs(size.Width - Width) + Math.Abs(size.Height - Height);
+                    if (dif < diference) result = size;
+                    diference = dif;
+                }
+                else if (size.Height >= result.Height && result.Height < Height)
+                    result = size;
+            }
+        }
+        return result;
+    }
+
+    private Size ChooseOptimalSize(Size[] choices, int width, int height, Size aspectRatio)
+    {
+        var bigEnough = new List<Size>();
+        int w = aspectRatio.Width;
+        int h = aspectRatio.Height;
+        foreach (Size option in choices)
+        {
+            if (option.Height == option.Width * h / w &&
+                option.Width >= width && option.Height >= height)
+                bigEnough.Add(option);
+        }
+
+        if (bigEnough.Count > 0)
+            return (Size)Collections.Min(bigEnough, new CompareSizesByArea());
+        else
+        {
+            return choices[0];
+        }
+    }
+    
+    private void AdjustAspectRatioFit(int videoWidth, int videoHeight)
+    {
+        Matrix txform = new Matrix();
+        float centerX = Math.Max((videoWidth - Width) / 2, 0);
+        float centerY = Math.Max((videoHeight - Height) / 2, 0);
+        float scaleX = (float)videoHeight / Height;
+        float scaleY = (float)videoWidth / Width;
+
+        txform.PostScale(Width > Height ? 1 : scaleX, Height <= Width ? scaleY : 1, centerX, centerY);
+        textureView.SetTransform(txform);
+    }
+
+    private Bitmap ApplyTransform(Bitmap bitmap)
+    {
+        Matrix txform = new Matrix();
+        float centerX = Math.Max((videoSize.Width - Width) / 2, 0);
+        float centerY = Math.Max((videoSize.Height - Height) / 2, 0);
+        float scaleX = (float)videoSize.Height / Height;
+        float scaleY = (float)videoSize.Width / Width;
+
+        txform.PostScale(Width > Height ? 1 : scaleX, Height <= Width ? scaleY : 1, centerX, centerY);
+        return Bitmap.CreateBitmap(bitmap, 0, 0, Width, Height, txform, false);
+    }
+
+    private void AdjustAspectRatioFill(int videoWidth, int videoHeight)
+    {
+        int viewWidth = previewSize.Width;
+        int viewHeight = previewSize.Height;
+        double aspectRatio = Math.Max((double)videoHeight / videoWidth, (double)videoWidth / videoHeight);
+        int newWidth, newHeight;
+
+        if (viewWidth <= viewHeight)
+        {
+            newWidth = videoWidth;
+            newHeight = (viewHeight * videoWidth) / viewWidth;
+        }
+        else
+        {
+            newHeight = videoHeight;
+            newWidth = (viewWidth * videoHeight) / viewHeight;
+        }
+
+        int xoff = (videoWidth - newWidth) / 2;
+        int yoff = (videoHeight - newHeight) / 2;
+
+        Matrix txform = new Matrix();
+        txform = textureView.GetTransform(txform);
+        //txform.SetScale((float)newWidth / viewWidth, (float)newHeight / viewHeight);
+        txform.PostTranslate(xoff, yoff);
+        textureView.SetTransform(txform);
+    }
+    
+    private void configureTransform(int viewWidth, int viewHeight)
+    {
+        if (null == context || null == previewSize || null == textureView)
+            return;
+
+        int rotation = (int)context.Display.Rotation;
+        var matrix = new Matrix();
+        var viewRect = new RectF(0, 0, viewWidth, viewHeight);
+        var bufferRect = new RectF(0, 0, previewSize.Height, previewSize.Width);
+        float centerX = viewRect.CenterX();
+        float centerY = viewRect.CenterY();
+        if ((int)SurfaceOrientation.Rotation90 == rotation || (int)SurfaceOrientation.Rotation270 == rotation)
+        {
+            bufferRect.Offset((centerX - bufferRect.CenterX()), (centerY - bufferRect.CenterY()));
+            matrix.SetRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.Fill);
+            float scale = System.Math.Max(
+                (float)viewHeight / previewSize.Height,
+                (float)viewHeight / previewSize.Width);
+            matrix.PostScale(scale, scale, centerX, centerY);
+            matrix.PostRotate(90 * (rotation - 2), centerX, centerY);
+        }
+        textureView.SetTransform(matrix);
+    }
+    
+    class ImageAnalyzer : Java.Lang.Object, ImageAnalysis.IAnalyzer
+    {
+        public IImageProxy Image { get; private set; }
+        public event EventHandler FrameReady;
+        public void Analyze(IImageProxy image)
+        {
+            Image = image;
+            FrameReady?.Invoke(this, EventArgs.Empty);
+            image.Close();
+        }
+    }
+    class RecordConsumer : Java.Lang.Object, AndroidX.Core.Util.IConsumer
+    {
+        public void Accept(Java.Lang.Object t)
+        {
+            
+        }
+    }
+
+    public class AutoFitTextureView : TextureView
+    {
+        private int mRatioWidth = 0;
+        private int mRatioHeight = 0;
+
+        public AutoFitTextureView(Context context)
+            : this(context, null)
+        {
+            SurfaceTextureAvailable += AutoFitTextureView_SurfaceTextureAvailable;
+        }
+
+        private void AutoFitTextureView_SurfaceTextureAvailable(object sender, SurfaceTextureAvailableEventArgs e)
+        {
+            System.Diagnostics.Debug.WriteLine($"NEW IMAGES={e.Width}x{e.Height} -> {Width}x{Height}");
+        }
+
+        public AutoFitTextureView(Context context, IAttributeSet attrs)
+            : this(context, attrs, 0)
+        {
+
+        }
+        public AutoFitTextureView(Context context, IAttributeSet attrs, int defStyle)
+            : base(context, attrs, defStyle)
+        {
+
+        }
+
+        public void SetAspectRatio(int width, int height)
+        {
+            if (width == 0 || height == 0)
+                throw new ArgumentException("Size cannot be negative.");
+            mRatioWidth = width;
+            mRatioHeight = height;
+            RequestLayout();
+        }
+
+        protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
+        {
+            base.OnMeasure(widthMeasureSpec, heightMeasureSpec);
+            int width = MeasureSpec.GetSize(widthMeasureSpec);
+            int height = MeasureSpec.GetSize(heightMeasureSpec);
+            if (0 == mRatioWidth || 0 == mRatioHeight)
+            {
+                SetMeasuredDimension(width, height);
+            }
+            else
+            {
+                if (width < (float)height * mRatioWidth / (float)mRatioHeight)
+                {
+                    SetMeasuredDimension(width, width * mRatioHeight / mRatioWidth);
+                }
+                else
+                {
+                    SetMeasuredDimension(height * mRatioWidth / mRatioHeight, height);
+                }
+            }
+        }
+    }
+    public class MySurfaceTextureListener : Java.Lang.Object, TextureView.ISurfaceTextureListener
+    {
+        //Camera2VideoFragment fragment;
+        //public MySurfaceTextureListener(Camera2VideoFragment frag)
+        public MySurfaceTextureListener()
+        {
+            //fragment = frag;
+        }
+
+        public void OnSurfaceTextureAvailable(SurfaceTexture surface_texture, int width, int height)
+        {
+            //fragment.openCamera(width, height);
+        }
+
+        public void OnSurfaceTextureSizeChanged(SurfaceTexture surface_texture, int width, int height)
+        {
+            System.Diagnostics.Debug.WriteLine($"SURFACE SIZE={width}x{height}");
+            //fragment.configureTransform(width, height);
+        }
+
+        public bool OnSurfaceTextureDestroyed(SurfaceTexture surface_texture)
+        {
+            return true;
+        }
+
+        public void OnSurfaceTextureUpdated(SurfaceTexture surface_texture)
+        {
+        }
+
+    }
+    public class MyCameraStateCallback : CameraDevice.StateCallback
+    {
+        MauiCameraView fragment;
+        public MyCameraStateCallback(MauiCameraView frag)
+        {
+            fragment = frag;
+        }
+        public override void OnOpened(CameraDevice camera)
+        {
+            fragment.cameraDevice = camera;
+            fragment.startPreview();
+            //fragment.cameraOpenCloseLock.Release();
+            //if (null != fragment.textureView)
+                //fragment.configureTransform(fragment.textureView.Width, fragment.textureView.Height);
+        }
+
+        public override void OnDisconnected(CameraDevice camera)
+        {
+            //fragment.cameraOpenCloseLock.Release();
+            camera.Close();
+            fragment.cameraDevice = null;
+        }
+
+        public override void OnError(CameraDevice camera, CameraError error)
+        {
+            //fragment.cameraOpenCloseLock.Release();
+            camera?.Close();
+            fragment.cameraDevice = null;
+            //if (null != fragment.Activity)
+            //    fragment.Activity.Finish();
+        }
+    }
+    public class PreviewCaptureStateCallback : CameraCaptureSession.StateCallback
+    {
+        MauiCameraView fragment;
+        public PreviewCaptureStateCallback(MauiCameraView frag)
+        {
+            fragment = frag;
+        }
+        public override void OnConfigured(CameraCaptureSession session)
+        {
+            fragment.previewSession = session;
+            fragment.updatePreview();
+
+        }
+
+        public override void OnConfigureFailed(CameraCaptureSession session)
+        {
+            //if (null != fragment.Activity)
+            //    Toast.MakeText(fragment.Activity, "Failed", ToastLength.Short).Show();
+        }
+    }
+}
+
+
diff --git a/Readme.md b/Readme.md
index 3247048..dbf9d59 100644
--- a/Readme.md
+++ b/Readme.md
@@ -17,6 +17,7 @@ A ContetView control for camera management with the next properties:
 | Take snapshot  | ✅  | ✅  | ✅  |
 | Save snapshot  | ✅  | ✅  | ✅  |
 | Barcode detection/decode  | ✅  | ✅  | ✅  |
+| Video/audio recording  | ✅  | ✅  | ✅  |
 
 ### Install and configure CameraView
 
@@ -39,7 +40,7 @@ A ContetView control for camera management with the next properties:
     	return builder.Build();
     }
     ```
-1. Add camera permissions to your application:
+1. Add camera/microphone permissions to your application:
 
 #### Android
 
@@ -47,6 +48,9 @@ In your `AndroidManifest.xml` file (Platforms\Android) add the following permiss
 
 ```xml
 <uses-permission android:name="android.permission.CAMERA" />
+<uses-permission android:name="android.permission.RECORD_AUDIO" />
+<uses-permission android:name="android.permission.RECORD_VIDEO" />
+
 ```
 
 #### iOS/MacCatalyst
@@ -56,12 +60,14 @@ In your `info.plist` file (Platforms\iOS / Platforms\MacCatalyst) add the follow
 ```xml
 <key>NSCameraUsageDescription</key>
 <string>This app uses camera for...</string>
+<key>NSMicrophoneUsageDescription</key>
+<string>This app needs access to the microphone for record videos</string>
 ```
 Make sure that you enter a clear and valid reason for your app to access the camera. This description will be shown to the user.
 
 #### Windows
 
-In your Package.appxmanifest file (Platforms\Windows) go to Capabilities and mark Web Camera.
+In your Package.appxmanifest file (Platforms\Windows) go to Capabilities and mark Web Camera and Microphone.
 
 For more information on permissions, see the [Microsoft Docs](https://docs.microsoft.com/dotnet/maui/platform-integration/appmodel/permissions).
 
@@ -69,7 +75,7 @@ For more information on permissions, see the [Microsoft Docs](https://docs.micro
 
 In XAML, make sure to add the right XML namespace:
 
-`xmlns:cv="xmlns:cv="clr-namespace:Camera.MAUI;assembly=Camera.MAUI"`
+`xmlns:cv="clr-namespace:Camera.MAUI;assembly=Camera.MAUI"`
 
 Use the control:
 ```xaml
@@ -81,12 +87,14 @@ Configure the events:
         cameraView.CamerasLoaded += CameraView_CamerasLoaded;
         cameraView.BarcodeDetected += CameraView_BarcodeDetected;
 ```
-Configure the camera to use:
+Configure the camera and microphone to use:
 ```csharp
     private void CameraView_CamerasLoaded(object sender, EventArgs e)
     {
-        if (cameraView.Cameras.Count > 0)
+        if (cameraView.NumCamerasDetected > 0)
         {
+            if (cameraView.NumMicrophonesDetected > 0)
+                cameraView.Microphone = cameraView.Microphones.First();
             cameraView.Camera = cameraView.Cameras.First();
             MainThread.BeginInvokeOnMainThread(async () =>
             {
@@ -143,8 +151,16 @@ if (cameraView.MaxZoomFactor >= 2.5f)
 Get a snapshot from the playback
 ```csharp
 ImageSource imageSource = cameraView.GetSnapShot(ImageFormat.PNG);
+bool result = cameraView.SaveSnapShot(ImageFormat.PNG, filePath);
+```
+Record a video:
+```csharp
+var result = await cameraView.StartRecordingAsync(Path.Combine(FileSystem.Current.CacheDirectory, "Video.mp4"));
+....
+result = cameraView.StopRecordingAsync();
 ```
-Get a snapshot MVVM:
+
+**Use Control with MVVM:**
 The control has several binding properties for take an snapshot:
 ```csharp
     /// Sets how often the SnapShot property is updated in seconds.
@@ -168,7 +184,42 @@ The control has several binding properties for take an snapshot:
     
     /// If true SnapShot property is refreshed according to the frequency set in the AutoSnapShotSeconds property
     public bool AutoSnapShotAsImageSource
+    /// Starts/Stops the Preview if camera property has been set
+    public bool AutoStartPreview
+    {
+        get { return (bool)GetValue(AutoStartPreviewProperty); }
+        set { SetValue(AutoStartPreviewProperty, value); }
+    }
+    /// Full path to file where record video will be recorded.
+    public string AutoRecordingFile
+    {
+        get { return (string)GetValue(AutoRecordingFileProperty); }
+        set { SetValue(AutoRecordingFileProperty, value); }
+    }
+    /// Starts/Stops record video to AutoRecordingFile if camera and microphone properties have been set
+    public bool AutoStartRecording
+    {
+        get { return (bool)GetValue(AutoStartRecordingProperty); }
+        set { SetValue(AutoStartRecordingProperty, value); }
+    }
 ```
+```xaml
+<cv:CameraView x:Name="cameraView" WidthRequest="300" HeightRequest="200"
+  BarCodeOptions="{Binding BarCodeOptions}" 
+  BarCodeResults="{Binding BarCodeResults, Mode=OneWayToSource}"
+  Cameras="{Binding Cameras, Mode=OneWayToSource}" Camera="{Binding Camera}" 
+  AutoStartPreview="{Binding AutoStartPreview}" 
+  NumCamerasDetected="{Binding NumCameras, Mode=OneWayToSource}"
+  AutoSnapShotAsImageSource="True" AutoSnapShotFormat="PNG" 
+  TakeAutoSnapShot="{Binding TakeSnapshot}" AutoSnapShotSeconds="{Binding SnapshotSeconds}"
+  Microphones="{Binding Microphones, Mode=OneWayToSource}" Microphone="{Binding Microphone}"
+  NumMicrophonesDetected="{Binding NumMicrophones, Mode=OneWayToSource}"
+  AutoRecordingFile="{Binding RecordingFile}" 
+  AutoStartRecording="{Binding AutoStartRecording}"/>
+  ```
+
+You have a complete example of MVVM in [MVVM Example](https://github.com/hjam40/Camera.MAUI/tree/master/Camera.MAUI.Test/MVVM)
+
 
 Enable and Handle barcodes detection:
 ```csharp