Camera Video Recording

samples/CommunityToolkit.Maui.Sample/Pages/Views/CameraView/CameraViewPage.xaml

@@ -57,7 +57,7 @@
             <Button Clicked="ZoomIn" Text="Zoom +" Grid.Column="2"/>
         </Grid>
 
-        <Grid Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="3" BackgroundColor="#80CCCCCC">
+        <Grid Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="5" BackgroundColor="#80CCCCCC">
 
             <FlexLayout Margin="5" JustifyContent="SpaceBetween" Wrap="Wrap">
 
@@ -76,6 +76,14 @@
 
                 <Button Command="{Binding StopCameraPreviewCommand, Source={x:Reference Camera}, x:DataType=toolkit:CameraView}" 
                         Text="StopCameraPreview" />
+                <Button Command="{Binding StartVideoRecordingCommand, Source={x:Reference Camera}, x:DataType=toolkit:CameraView}"
+                        CommandParameter="{Binding Stream}"
+                        Text="StartVideoRecording" />
+
+                <Button Command="{Binding StopVideoRecordingCommand, Source={x:Reference Camera}, x:DataType=toolkit:CameraView}" 
+                        Text="StopVideoRecording" />
+
+                <Button Command="{Binding SaveVideoCommand}" Text="GetStream" />
 
             </FlexLayout>
         </Grid>

samples/CommunityToolkit.Maui.Sample/ViewModels/Views/CameraView/CameraViewViewModel.cs

@@ -1,5 +1,6 @@
 using CommunityToolkit.Maui.Core;
 using CommunityToolkit.Maui.Core.Primitives;
+using CommunityToolkit.Maui.Storage;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 
@@ -13,6 +14,8 @@ public partial class CameraViewViewModel(ICameraProvider cameraProvider) : BaseV
 
 	public CancellationToken Token => CancellationToken.None;
 
+	public Stream Stream { get; } = new MemoryStream();
+
 	public ICollection<CameraFlashMode> FlashModes { get; } = Enum.GetValues<CameraFlashMode>();
 
 	[ObservableProperty]
@@ -78,4 +81,10 @@ void UpdateResolutionText()
 	{
 		ResolutionText = $"Selected Resolution: {SelectedResolution.Width} x {SelectedResolution.Height}";
 	}
+
+	[RelayCommand]
+	async Task SaveVideo()
+	{
+		await FileSaver.SaveAsync("recording.mp4", Stream);
+	}
 }

src/CommunityToolkit.Maui.Camera/CameraManager.android.cs

@@ -1,16 +1,28 @@
-using System.Runtime.Versioning;
+using System.IO;
+using System.Runtime.Versioning;
 using Android.Content;
+using Android.Hardware.Camera2;
+using Android.Hardware.Camera2.Params;
+using Android.Media;
+using Android.OS;
+using Android.Runtime;
+using Android.SE.Omapi;
 using Android.Views;
 using AndroidX.Camera.Core;
 using AndroidX.Camera.Core.Impl.Utils.Futures;
 using AndroidX.Camera.Core.ResolutionSelector;
 using AndroidX.Camera.Lifecycle;
+using AndroidX.Camera.Video;
 using AndroidX.Core.Content;
 using AndroidX.Lifecycle;
 using CommunityToolkit.Maui.Extensions;
+using Java.IO;
 using Java.Lang;
 using Java.Util.Concurrent;
 using static Android.Media.Image;
+using static Android.Print.PrintAttributes;
+using static AndroidX.Camera.Core.Internal.CameraUseCaseAdapter;
+using Exception = System.Exception;
 using Math = System.Math;
 
 namespace CommunityToolkit.Maui.Core;
@@ -32,6 +44,15 @@ partial class CameraManager
 	ResolutionFilter? resolutionFilter;
 	OrientationListener? orientationListener;
 
+	MediaRecorder? mediaRecorder;
+	CameraDevice? cameraDevice;
+	CameraCaptureSession? captureSession;
+	ParcelFileDescriptor? writeFd;
+	ParcelFileDescriptor? readFd;
+	Task? pipeTask;
+	HandlerThread? cameraThread;
+	Handler? cameraHandler;
+
 	public void Dispose()
 	{
 		Dispose(true);
@@ -258,6 +279,124 @@ protected virtual partial ValueTask PlatformTakePicture(CancellationToken token)
 		return ValueTask.CompletedTask;
 	}
 
+	protected virtual async partial Task PlatformStartVideoRecording(System.IO.Stream stream, CancellationToken token)
+	{
+		var cameraManager = (Android.Hardware.Camera2.CameraManager)context.GetSystemService(Context.CameraService)!;
+		var audioManager = (AudioManager)context.GetSystemService(Context.AudioService)!;
+
+		cameraThread = new HandlerThread("CameraThread");
+		cameraThread.Start();
+		cameraHandler = new Handler(cameraThread.Looper!);
+
+		mediaRecorder = OperatingSystem.IsAndroidVersionAtLeast(31)
+			? new MediaRecorder(context)
+			: new MediaRecorder();
+
+		audioManager.Mode = Mode.Normal;
+
+		mediaRecorder.SetAudioSource(AudioSource.Mic);
+		mediaRecorder.SetVideoSource(VideoSource.Surface);
+		mediaRecorder.SetOutputFormat(OutputFormat.Mpeg4);
+
+		var pipe = ParcelFileDescriptor.CreatePipe()!;
+		writeFd = pipe[1];
+		readFd = pipe[0];
+
+		mediaRecorder.SetOutputFile(writeFd.FileDescriptor);
+		mediaRecorder.SetVideoEncodingBitRate(10_000_000);
+		mediaRecorder.SetVideoFrameRate(30);
+		mediaRecorder.SetVideoEncoder(VideoEncoder.H264);
+		mediaRecorder.SetAudioEncoder(AudioEncoder.Aac);
+		mediaRecorder.Prepare();
+
+		// Start background streaming to .NET stream
+		pipeTask = Task.Run(async () =>
+		{
+			try
+			{
+				using var inputStream = new ParcelFileDescriptor.AutoCloseInputStream(readFd);
+				byte[] buffer = new byte[81920];
+				int bytesRead;
+				while ((bytesRead = inputStream.Read(buffer, 0, buffer.Length)) > 0 && !token.IsCancellationRequested)
+				{
+					await stream.WriteAsync(buffer.AsMemory(0, bytesRead), token);
+					await stream.FlushAsync(token);
+				}
+			}
+			catch (System.OperationCanceledException) { }
+			catch (Exception ex)
+			{
+				System.Diagnostics.Debug.WriteLine($"[VideoRecorder] CopyToAsync failed: {ex}");
+			}
+		}, token);
+
+		// Open camera and start recording session
+		var openTcs = new TaskCompletionSource();
+
+		var cameraCallback = new CameraStateListener(device =>
+		{
+			cameraDevice = device;
+
+			var surfaces = new List<Surface> { mediaRecorder.Surface! };
+			var sessionCallback = new CaptureStateListener(session =>
+			{
+				captureSession = session;
+				var builder = cameraDevice.CreateCaptureRequest(CameraTemplate.Record);
+				builder.AddTarget(mediaRecorder.Surface!);
+				session.SetRepeatingRequest(builder.Build(), null, cameraHandler);
+
+				mediaRecorder.Start();
+				openTcs.TrySetResult();
+			});
+
+			device.CreateCaptureSession(surfaces, sessionCallback, cameraHandler);
+		});
+
+		cameraManager.OpenCamera(cameraView.SelectedCamera!.DeviceId, cameraCallback, cameraHandler);
+
+		await openTcs.Task;
+	}
+
+	protected virtual async partial Task PlatformStopVideoRecording(CancellationToken token)
+	{
+		ArgumentNullException.ThrowIfNull(cameraExecutor);
+		try
+		{
+			mediaRecorder?.Stop();
+		}
+		catch (Exception ex)
+		{
+			System.Diagnostics.Debug.WriteLine($"[VideoRecorder] Stop failed: {ex}");
+		}
+
+		mediaRecorder?.Release();
+		mediaRecorder = null;
+
+		captureSession?.Close();
+		cameraDevice?.Close();
+		captureSession = null;
+		cameraDevice = null;
+
+		writeFd?.Close();
+		readFd?.Close();
+		writeFd = null;
+		readFd = null;
+
+		if (pipeTask is not null)
+		{
+			await pipeTask;
+			pipeTask = null;
+		}
+
+		if (cameraThread != null)
+		{
+			cameraThread.QuitSafely();
+			cameraThread.Join();
+			cameraThread = null;
+			cameraHandler = null;
+		}
+	}
+
 	void SetImageCaptureTargetRotation(int rotation)
 	{
 		if (imageCapture is not null)
@@ -379,4 +518,23 @@ public override void OnOrientationChanged(int orientation)
 			callback.Invoke(orientation);
 		}
 	}
+}
+
+public class CameraStateListener : CameraDevice.StateCallback
+{
+	readonly Action<CameraDevice> onOpened;
+	public CameraStateListener(Action<CameraDevice> onOpened) => this.onOpened = onOpened;
+
+	public override void OnOpened(CameraDevice camera) => onOpened(camera);
+	public override void OnDisconnected(CameraDevice camera) => camera.Close();
+	public override void OnError(CameraDevice camera, [GeneratedEnum] CameraError error) => camera.Close();
+}
+
+public class CaptureStateListener : CameraCaptureSession.StateCallback
+{
+	readonly Action<CameraCaptureSession> onConfigured;
+	public CaptureStateListener(Action<CameraCaptureSession> onConfigured) => this.onConfigured = onConfigured;
+
+	public override void OnConfigured(CameraCaptureSession session) => onConfigured(session);
+	public override void OnConfigureFailed(CameraCaptureSession session) => session.Close();
 }

src/CommunityToolkit.Maui.Camera/CameraManager.macios.cs

@@ -191,6 +191,10 @@
 	{
 	}
 
+	protected virtual partial Task PlatformStartVideoRecording(Stream stream, CancellationToken token) => throw new NotSupportedException("notSupportedMessage");
+	protected virtual partial Task PlatformStopVideoRecording(CancellationToken token) => throw new NotSupportedException("notSupportedMessage");
+
+
 	protected virtual async partial ValueTask PlatformTakePicture(CancellationToken token)
 	{
 		ArgumentNullException.ThrowIfNull(photoOutput);
@@ -203,7 +207,7 @@
 			var photoOutputConnection = photoOutput.ConnectionFromMediaType(avMediaTypeVideo);
 			if (photoOutputConnection is not null)
 			{
 				photoOutputConnection.VideoOrientation = videoOrientation;
 			}
 		}
 
@@ -270,7 +274,7 @@
 		IEnumerable<UIScene> scenes = UIApplication.SharedApplication.ConnectedScenes;
 		var interfaceOrientation = scenes.FirstOrDefault() is UIWindowScene windowScene
 			? windowScene.InterfaceOrientation
 			: UIApplication.SharedApplication.StatusBarOrientation;
 
 		return interfaceOrientation switch
 		{
@@ -346,7 +350,7 @@
 		{
 			if (PreviewLayer.Connection is not null)
 			{
 				PreviewLayer.Connection.VideoOrientation = videoOrientation;
 			}
 		}
 	}

src/CommunityToolkit.Maui.Camera/CameraManager.net.cs

@@ -14,6 +14,8 @@ partial class CameraManager
 
 	public partial ValueTask UpdateCaptureResolution(Size resolution, CancellationToken token) => throw new NotSupportedException(notSupportedMessage);
 
+	protected virtual partial Task PlatformStartVideoRecording(Stream stream, CancellationToken token) => throw new NotSupportedException(notSupportedMessage);
+	protected virtual partial Task PlatformStopVideoRecording(CancellationToken token) => throw new NotSupportedException(notSupportedMessage);
 	protected virtual partial Task PlatformStartCameraPreview(CancellationToken token) => throw new NotSupportedException(notSupportedMessage);
 
 	protected virtual partial void PlatformStopCameraPreview() => throw new NotSupportedException(notSupportedMessage);

src/CommunityToolkit.Maui.Camera/CameraManager.shared.cs

@@ -13,9 +13,9 @@
 /// <exception cref="NullReferenceException">Thrown when no <see cref="CameraProvider"/> can be resolved.</exception>
 /// <exception cref="InvalidOperationException">Thrown when there are no cameras available.</exception>
 partial class CameraManager(
 	IMauiContext mauiContext,
 	ICameraView cameraView,
 	ICameraProvider cameraProvider,
 	Action onLoaded) : IDisposable
 {
 	internal Action OnLoaded { get; } = onLoaded;
@@ -52,6 +52,19 @@
 	/// <returns>A <see cref="ValueTask"/> that can be awaited.</returns>
 	public Task StartCameraPreview(CancellationToken token) => PlatformStartCameraPreview(token);
 
+	/// <summary>
+	/// Starts the video recording.
+	/// </summary>
+	/// <returns>A <see cref="ValueTask"/> that can be awaited.</returns>
+	public Task StartVideoRecording(Stream stream, CancellationToken token) => PlatformStartVideoRecording(stream, token);
+
+
+	/// <summary>
+	/// Starts the video recording.
+	/// </summary>
+	/// <returns>A <see cref="ValueTask"/> that can be awaited.</returns>
+	public Task StopVideoRecording(CancellationToken token) => PlatformStopVideoRecording(token);
+
 	/// <summary>
 	/// Stops the camera preview.
 	/// </summary>
@@ -131,4 +144,8 @@
 	/// Stops the preview from the camera, at the platform-specific level.
 	/// </summary>
 	protected virtual partial void PlatformStopCameraPreview();
+
+	protected virtual partial Task PlatformStartVideoRecording(Stream stream, CancellationToken token);
+
+	protected virtual partial Task PlatformStopVideoRecording(CancellationToken token);
 }

src/CommunityToolkit.Maui.Camera/CameraManager.tizen.cs

@@ -23,4 +23,7 @@ partial class CameraManager
 	protected virtual partial void PlatformDisconnect() => throw new NotSupportedException(notSupportedMessage);
 
 	protected virtual partial ValueTask PlatformTakePicture(CancellationToken token) => throw new NotSupportedException(notSupportedMessage);
+	protected virtual partial Task PlatformStartVideoRecording(Stream stream, CancellationToken token) => throw new NotSupportedException(notSupportedMessage);
+	protected virtual partial Task PlatformStopVideoRecording(CancellationToken token) => throw new NotSupportedException(notSupportedMessage);
+
 }

src/CommunityToolkit.Maui.Camera/CameraManager.windows.cs

@@ -1,4 +1,5 @@
-using System.Runtime.Versioning;
+using System;
+using System.Runtime.Versioning;
 using CommunityToolkit.Maui.Extensions;
 using Microsoft.UI.Xaml.Controls;
 using Windows.Media.Capture;
@@ -14,6 +15,7 @@ partial class CameraManager
 	MediaPlayerElement? mediaElement;
 	MediaCapture? mediaCapture;
 	MediaFrameSource? frameSource;
+	LowLagMediaRecording? mediaRecording;
 
 	public MediaPlayerElement CreatePlatformView()
 	{
@@ -202,4 +204,45 @@ protected async Task PlatformUpdateResolution(Size resolution, CancellationToken
 			await mediaCapture.VideoDeviceController.SetMediaStreamPropertiesAsync(MediaStreamType.Photo, filteredPropertiesList.First()).AsTask(token);
 		}
 	}
+
+	protected virtual async partial Task PlatformStartVideoRecording(Stream stream, CancellationToken token)
+	{
+		if (!IsInitialized || mediaCapture is null || mediaElement is null)
+		{
+			return;
+		}
+
+		MediaEncodingProfile profile = MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto);
+		mediaRecording = await mediaCapture.PrepareLowLagRecordToStreamAsync(profile, stream.AsRandomAccessStream());
+
+		frameSource = mediaCapture.FrameSources.FirstOrDefault(source =>
+			source.Value.Info.MediaStreamType == MediaStreamType.VideoRecord
+			&& source.Value.Info.SourceKind == MediaFrameSourceKind.Color).Value;
+		if (frameSource != null)
+		{
+			var frameFormat = frameSource.SupportedFormats
+					.OrderByDescending(f => f.VideoFormat.Width * f.VideoFormat.Height).FirstOrDefault();
+
+			if (frameFormat != null)
+			{
+				await frameSource.SetFormatAsync(frameFormat);
+				mediaElement.AutoPlay = true;
+				mediaElement.Source = MediaSource.CreateFromMediaFrameSource(frameSource);
+				await mediaRecording.StartAsync();
+			}
+		}
+	}
+
+	protected virtual async partial Task PlatformStopVideoRecording(CancellationToken token)
+	{
+		if (!IsInitialized || mediaElement is null)
+		{
+			return;
+		}
+
+		if (mediaRecording != null)
+		{
+			await mediaRecording.StopAsync();
+		}
+	}
 }

src/CommunityToolkit.Maui.Camera/Primitives/CameraViewDefaults.shared.cs

@@ -47,18 +47,30 @@
 	internal static Command<CancellationToken> CreateCaptureImageCommand(BindableObject bindable)
 	{
 		var cameraView = (CameraView)bindable;
 		return new(async token => await cameraView.CaptureImage(token).ConfigureAwait(false));
 	}
 
 	internal static Command<CancellationToken> CreateStartCameraPreviewCommand(BindableObject bindable)
 	{
 		var cameraView = (CameraView)bindable;
 		return new(async token => await cameraView.StartCameraPreview(token).ConfigureAwait(false));
 	}
 
 	internal static ICommand CreateStopCameraPreviewCommand(BindableObject bindable)
 	{
 		var cameraView = (CameraView)bindable;
 		return new Command(_ => cameraView.StopCameraPreview());
 	}
+
+	internal static Command<Stream> CreateStartVideoRecordingCommand(BindableObject bindable)
+	{
+		var cameraView = (CameraView)bindable;
+		return new(async stream => await cameraView.StartVideoRecording(stream, CancellationToken.None).ConfigureAwait(false));
+	}
+
+	internal static ICommand CreateStopVideoRecordingCommand(BindableObject bindable)
+	{
+		var cameraView = (CameraView)bindable;
+		return new Command(_ => cameraView.StopVideoRecording(CancellationToken.None));
+	}
 }