feat(android): share podcast playback and foreground broadcasting

Add native Camera2 capture, MPEG-TS segmentation and foreground service with notification stop. Reuse shared authenticated uploads and replay finalization, add capture regression tests and document platform limitations. Update Avalonia to 12.1.4.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

src/PostIt/PostIt.Android/Services/AndroidPodcastCapture.cs

@@ -0,0 +1,309 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.Versioning;
+using System.Threading;
+using System.Threading.Tasks;
+using Android.Content;
+using Android.Hardware.Camera2;
+using Android.Hardware.Camera2.Params;
+using Android.Media;
+using Android.OS;
+using Android.Views;
+using Microsoft.Win32.SafeHandles;
+using PostIt.Services;
+
+namespace PostIt.Android.Services;
+
+[SupportedOSPlatform("android26.0")]
+internal sealed class AndroidPodcastCapture : IPodcastCapture
+{
+    private readonly PodcastCaptureService _service;
+    private readonly SemaphoreSlim _stopGate = new(1);
+    private readonly TaskCompletionSource _completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    private readonly Handler _handler = new(Looper.MainLooper!);
+    private CameraDevice? _camera;
+    private CameraCaptureSession? _session;
+    private MediaRecorder? _recorder;
+    private Surface? _surface;
+    private ParcelFileDescriptor? _readPipe;
+    private ParcelFileDescriptor? _writePipe;
+    private Task _pump = Task.CompletedTask;
+    private Exception? _failure;
+    private bool _stopped;
+    private bool _stopRequested;
+    private bool _started;
+    private bool _disposed;
+    public Task Completion => _completion.Task;
+
+    private AndroidPodcastCapture(PodcastCaptureService service) => _service = service;
+
+    private static CameraManager GetManager(Context context)
+        => context.GetSystemService(Context.CameraService) as CameraManager
+            ?? throw new InvalidOperationException("Service camera Android indisponible.");
+
+    public static PodcastCaptureDevices GetDevices()
+    {
+        var activity = MainActivity.Current ?? throw new InvalidOperationException("Activite Android indisponible.");
+        var manager = GetManager(activity);
+        var cameras = new List<CaptureDevice>();
+        foreach (var id in manager.GetCameraIdList())
+        {
+            using var characteristics = manager.GetCameraCharacteristics(id);
+            using var facing = characteristics.Get(CameraCharacteristics.LensFacing) as Java.Lang.Integer;
+            cameras.Add(new(facing?.IntValue() == (int)LensFacing.Front ? "Camera avant" : "Camera arriere", id));
+        }
+        return new(cameras, [new("Sans microphone", ""), new("Microphone Android", "microphone")]);
+    }
+
+    public static async Task RequestPermissionsAsync(string? microphone, CancellationToken ct)
+    {
+        var activity = MainActivity.Current ?? throw new InvalidOperationException("Activite Android indisponible.");
+        await PodcastPermissions.EnsureAsync(activity, microphone is not null, ct);
+        if (!MainActivity.IsForeground)
+            throw new InvalidOperationException("Revenez dans PostIt pour demarrer la camera.");
+    }
+
+    public static async Task<IPodcastCapture> StartAsync(string camera, string? microphone, string directory, CancellationToken ct)
+    {
+        await RequestPermissionsAsync(microphone, ct);
+        var activity = MainActivity.Current ?? throw new InvalidOperationException("Activite Android indisponible.");
+        var service = await PodcastCaptureService.StartAsync(activity, microphone is not null, ct);
+        var capture = new AndroidPodcastCapture(service);
+        service.Capture = capture;
+        try
+        {
+            ct.ThrowIfCancellationRequested();
+            await capture.StartNativeAsync(camera, microphone is not null, directory, ct);
+            return capture;
+        }
+        catch
+        {
+            await capture.DisposeAsync();
+            throw;
+        }
+    }
+
+    private async Task StartNativeAsync(string cameraId, bool microphone, string directory, CancellationToken ct)
+    {
+        await _stopGate.WaitAsync(ct);
+        try { await ConfigureNativeAsync(cameraId, microphone, directory, ct); }
+        finally { _stopGate.Release(); }
+    }
+
+    private async Task ConfigureNativeAsync(string cameraId, bool microphone, string directory, CancellationToken ct)
+    {
+        var manager = GetManager(_service);
+        using var characteristics = manager.GetCameraCharacteristics(cameraId);
+        using var formats = characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap) as StreamConfigurationMap
+            ?? throw new InvalidOperationException("Formats camera indisponibles.");
+        var sizes = formats.GetOutputSizes(Java.Lang.Class.FromType(typeof(MediaRecorder)))
+            ?? throw new InvalidOperationException("Aucun format video disponible.");
+        var size = sizes.Where(s => s.Width <= 640 && s.Height <= 480)
+            .OrderByDescending(s => s.Width * s.Height).FirstOrDefault()
+            ?? throw new InvalidOperationException("La camera ne propose aucun format jusqu'a 480p.");
+#pragma warning disable CS0618
+        _recorder = OperatingSystem.IsAndroidVersionAtLeast(31)
+            ? new MediaRecorder(_service) : new MediaRecorder();
+#pragma warning restore CS0618
+        _recorder.Error += OnRecorderError;
+        if (microphone) _recorder.SetAudioSource(AudioSource.Mic);
+        _recorder.SetVideoSource(VideoSource.Surface);
+        _recorder.SetOutputFormat(OutputFormat.Mpeg2Ts);
+        _recorder.SetVideoSize(size.Width, size.Height);
+        _recorder.SetVideoFrameRate(30);
+        _recorder.SetVideoEncodingBitRate(1200000);
+        _recorder.SetVideoEncoder(VideoEncoder.H264);
+        if (microphone)
+        {
+            _recorder.SetAudioSamplingRate(48000);
+            _recorder.SetAudioChannels(1);
+            _recorder.SetAudioEncodingBitRate(96000);
+            _recorder.SetAudioEncoder(AudioEncoder.Aac);
+        }
+        var pipe = ParcelFileDescriptor.CreatePipe()
+            ?? throw new IOException("Creation du canal MPEG-TS impossible.");
+        _readPipe = pipe[0];
+        _writePipe = pipe[1];
+        _recorder.SetOutputFile(_writePipe.FileDescriptor);
+        await Task.Run(_recorder.Prepare, ct);
+        ct.ThrowIfCancellationRequested();
+        if (_stopRequested) throw new System.OperationCanceledException("Demarrage de la capture annule.");
+        _surface = _recorder.Surface ?? throw new InvalidOperationException("Surface encodeur indisponible.");
+        var opened = new TaskCompletionSource<CameraDevice>(TaskCreationOptions.RunContinuationsAsynchronously);
+        manager.OpenCamera(cameraId, new DeviceCallback(this, opened), _handler);
+        _camera = await opened.Task.WaitAsync(TimeSpan.FromSeconds(10), ct);
+        var configured = new TaskCompletionSource<CameraCaptureSession>(TaskCreationOptions.RunContinuationsAsynchronously);
+#pragma warning disable CS0618, CA1422
+        _camera.CreateCaptureSession(new List<Surface> { _surface }, new SessionCallback(this, configured), _handler);
+#pragma warning restore CS0618, CA1422
+        _session = await configured.Task.WaitAsync(TimeSpan.FromSeconds(10), ct);
+        ct.ThrowIfCancellationRequested();
+        if (_stopRequested) throw new System.OperationCanceledException("Demarrage de la capture annule.");
+        using var request = _camera.CreateCaptureRequest(CameraTemplate.Record);
+        request.AddTarget(_surface);
+        using var built = request.Build();
+        _session.SetRepeatingRequest(built, null, _handler);
+        var handle = new SafeFileHandle((IntPtr)_readPipe.Fd, ownsHandle: false);
+        var stream = new FileStream(handle, FileAccess.Read);
+        _pump = Task.Run(async () =>
+        {
+            using (handle)
+            using (stream)
+            {
+                try
+                {
+                    await new TransportStreamCapture(directory).RunAsync(stream, CancellationToken.None);
+                    if (_failure is not null) throw new IOException("Capture Android interrompue.", _failure);
+                    if (!_stopped) throw new IOException("Le flux de capture Android s'est ferme prematurement.");
+                    _completion.TrySetResult();
+                }
+                catch (Exception ex)
+                {
+                    _completion.TrySetException(ex);
+                    // Drain until MediaRecorder stops, so its writer cannot block Stop().
+                    await stream.CopyToAsync(System.IO.Stream.Null);
+                }
+            }
+        });
+        await Task.Run(_recorder.Start, ct);
+        _started = true;
+        _writePipe.Close();
+        _writePipe.Dispose();
+        _writePipe = null;
+    }
+
+    private sealed class DeviceCallback(AndroidPodcastCapture capture, TaskCompletionSource<CameraDevice> opened)
+        : CameraDevice.StateCallback
+    {
+        public override void OnOpened(CameraDevice camera)
+        {
+            if (capture._stopRequested || opened.Task.IsCompleted)
+            {
+                camera.Close();
+                opened.TrySetException(new IOException("Ouverture camera annulee."));
+            }
+            else
+            {
+                capture._camera = camera;
+                opened.TrySetResult(camera);
+            }
+        }
+
+        public override void OnDisconnected(CameraDevice camera) => Fail(camera, "Camera Android deconnectee.");
+        public override void OnError(CameraDevice camera, CameraError error) => Fail(camera, $"Erreur camera Android : {error}.");
+        private void Fail(CameraDevice camera, string message)
+        {
+            camera.Close();
+            var error = new IOException(message);
+            opened.TrySetException(error);
+            capture.Fail(error);
+        }
+    }
+
+    private sealed class SessionCallback(AndroidPodcastCapture capture, TaskCompletionSource<CameraCaptureSession> configured)
+        : CameraCaptureSession.StateCallback
+    {
+        public override void OnConfigured(CameraCaptureSession session)
+        {
+            if (capture._stopRequested || configured.Task.IsCompleted)
+            {
+                session.Close();
+                configured.TrySetException(new IOException("Configuration camera annulee."));
+            }
+            else
+            {
+                capture._session = session;
+                configured.TrySetResult(session);
+            }
+        }
+
+        public override void OnConfigureFailed(CameraCaptureSession session)
+        {
+            session.Close();
+            var error = new IOException("Configuration de la capture Android impossible.");
+            configured.TrySetException(error);
+            capture.Fail(error);
+        }
+    }
+
+    private void OnRecorderError(object? sender, MediaRecorder.ErrorEventArgs e)
+        => Fail(new IOException($"Erreur encodeur Android : {e.What}/{e.Extra}."));
+
+    private void Fail(Exception error)
+    {
+        if (_stopped) return;
+        _failure = error;
+        _completion.TrySetException(error);
+        RequestStop();
+    }
+
+    internal async void RequestStop()
+    {
+        try { await StopAsync(); }
+        catch (Exception ex) { global::Android.Util.Log.Error("PostIt.Podcast", ex.ToString()); }
+    }
+
+    public async Task StopAsync()
+    {
+        _stopRequested = true;
+        await _stopGate.WaitAsync();
+        try
+        {
+            if (_stopped) return;
+            _stopped = true;
+            await Task.Run(StopNative);
+            await _pump;
+        }
+        finally { _stopGate.Release(); }
+    }
+
+    private void StopNative()
+    {
+        try { if (_started) _recorder?.Stop(); }
+        catch (Java.Lang.RuntimeException ex)
+        {
+            _failure = ex;
+            _completion.TrySetException(new IOException("L'encodeur Android n'a pas pu finaliser la capture.", ex));
+        }
+        finally
+        {
+            _started = false;
+            _session?.Close();
+            _session?.Dispose();
+            _session = null;
+            _camera?.Close();
+            _camera?.Dispose();
+            _camera = null;
+            if (_recorder is not null)
+            {
+                _recorder.Error -= OnRecorderError;
+                _recorder.Release();
+                _recorder.Dispose();
+                _recorder = null;
+            }
+            _surface?.Dispose();
+            _surface = null;
+            _writePipe?.Close();
+            _writePipe?.Dispose();
+            _writePipe = null;
+        }
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        if (_disposed) return;
+        _disposed = true;
+        try { await StopAsync(); }
+        finally
+        {
+            _readPipe?.Dispose();
+            _readPipe = null;
+            _service.Capture = null;
+            _service.StopSelf();
+            _handler.Dispose();
+            _stopGate.Dispose();
+        }
+    }
+}