feat(archive): finish phase 16 — share, calendar cache, export test

- Mobile clip export hands the file to the native share sheet (no visible save
  path on phone); desktop unchanged (reveal-in-folder via IShareService)
- Calendar caches per-month aggregates; month navigation reuses them, page
  re-entry (LoadAsync) clears so new recordings show
- Integration test (Skippable on MediaMTX): record -> probe -> export -> probe,
  asserts real duration + clip length ~ selection
- ROADMAP: Phase 16 -> Done

Author: keyldev

docs/ROADMAP.md

@@ -57,7 +57,7 @@ and scope live in the planning docs (`dashboard-ideas-roadmap-ru.md`).
 | 13 | SSH device suite | SSH terminal, SCP file manager, open-in-browser, config push | ✅ Done |
 | 14 | Snapshots & viewer | Always-HD snapshot, snapshot browser, built-in viewer + basic editor | ✅ Done |
 | 15 | Local AI analytics | ONNX object detection per camera, auto-record, control center, CPU fallback | ✅ Done |
-| 16 | Archive pro | Fragmented MP4, activity calendar, timeline zoom, clip export | 📋 Planned |
+| 16 | Archive pro | Fragmented MP4, activity calendar, timeline zoom, clip export | ✅ Done |
 | 17 | Community & app-level | Tabbed layouts, config export/import, notifications, white-label, issue reporter, RBAC | 📋 Planned |
 | 18 | Streq remote access | Cloud multistreaming across devices: LAN/overlay/relay routing, enrollment, WebRTC/HLS, cross-device sync | 📋 Planned |
 

src/OpenIPC.Viewer.App/Services/RecordingPlayerPageFactory.cs

@@ -14,6 +14,7 @@ public sealed class RecordingPlayerPageFactory
     private readonly IEventRepository _events;
     private readonly IClipExporter _exporter;
     private readonly IDialogService _dialogs;
+    private readonly OpenIPC.Viewer.Core.Platform.IShareService _share;
     private readonly ILoggerFactory _loggerFactory;
 
     public RecordingPlayerPageFactory(
@@ -22,17 +23,19 @@ public RecordingPlayerPageFactory(
         IEventRepository events,
         IClipExporter exporter,
         IDialogService dialogs,
+        OpenIPC.Viewer.Core.Platform.IShareService share,
         ILoggerFactory loggerFactory)
     {
         _engine = engine;
         _probe = probe;
         _events = events;
         _exporter = exporter;
         _dialogs = dialogs;
+        _share = share;
         _loggerFactory = loggerFactory;
     }
 
     public RecordingPlayerPageViewModel Create(Recording recording, string cameraName) =>
-        new(recording, cameraName, _engine, _probe, _events, _exporter, _dialogs,
+        new(recording, cameraName, _engine, _probe, _events, _exporter, _dialogs, _share,
             _loggerFactory.CreateLogger<RecordingPlayerPageViewModel>());
 }

src/OpenIPC.Viewer.App/ViewModels/ArchiveCalendarViewModel.cs

@@ -23,6 +23,12 @@ public sealed partial class ArchiveCalendarViewModel : ViewModelBase
     private readonly IEventRepository _events;
     private readonly ILogger<ArchiveCalendarViewModel> _logger;
 
+    // Per-month aggregate cache (Phase 16.3). Flipping months within a session
+    // reuses it; LoadAsync (page re-entry) clears it so new recordings show.
+    private readonly Dictionary<(int Year, int Month), MonthActivity> _cache = new();
+
+    private sealed record MonthActivity(IReadOnlyDictionary<DateTime, DayActivity> Activity, int MaxTotal);
+
     // Fired with the selected local date, or null for "all days".
     public event Action<DateTime?>? DaySelected;
 
@@ -54,27 +60,40 @@ public ArchiveCalendarViewModel(
     public string MonthLabel =>
         new DateTime(Year, Month, 1).ToString("MMMM yyyy", CultureInfo.CurrentCulture);
 
-    public async Task LoadAsync(CancellationToken ct)
+    // Page-entry refresh: drop cached months so freshly-recorded days appear.
+    public Task LoadAsync(CancellationToken ct)
+    {
+        _cache.Clear();
+        return ShowMonthAsync(ct);
+    }
+
+    private async Task ShowMonthAsync(CancellationToken ct)
     {
         try
         {
-            var tz = TimeZoneInfo.Local;
-            var recordings = await _recordings.ListAsync(cameraId: null, ct).ConfigureAwait(true);
-            // Events since the start of the month (local) minus a day, in UTC.
-            var monthStartUtc = TimeZoneInfo.ConvertTimeToUtc(
-                DateTime.SpecifyKind(new DateTime(Year, Month, 1).AddDays(-1), DateTimeKind.Unspecified), tz);
-            var events = await _events
-                .ListAsync(cameraId: null, kind: null, since: monthStartUtc, limit: 20000, ct)
-                .ConfigureAwait(true);
-
-            var activity = CalendarActivity.ForMonth(
-                Year, Month,
-                recordings.Select(r => r.StartedAt),
-                events.Select(e => e.OccurredAt),
-                tz);
-
-            var maxTotal = activity.Count == 0 ? 0 : activity.Values.Max(d => d.Total);
-            BuildGrid(activity, maxTotal);
+            if (!_cache.TryGetValue((Year, Month), out var month))
+            {
+                var tz = TimeZoneInfo.Local;
+                var recordings = await _recordings.ListAsync(cameraId: null, ct).ConfigureAwait(true);
+                // Events since the start of the month (local) minus a day, in UTC.
+                var monthStartUtc = TimeZoneInfo.ConvertTimeToUtc(
+                    DateTime.SpecifyKind(new DateTime(Year, Month, 1).AddDays(-1), DateTimeKind.Unspecified), tz);
+                var events = await _events
+                    .ListAsync(cameraId: null, kind: null, since: monthStartUtc, limit: 20000, ct)
+                    .ConfigureAwait(true);
+
+                var activity = CalendarActivity.ForMonth(
+                    Year, Month,
+                    recordings.Select(r => r.StartedAt),
+                    events.Select(e => e.OccurredAt),
+                    tz);
+
+                var maxTotal = activity.Count == 0 ? 0 : activity.Values.Max(d => d.Total);
+                month = new MonthActivity(activity, maxTotal);
+                _cache[(Year, Month)] = month;
+            }
+
+            BuildGrid(month.Activity, month.MaxTotal);
         }
         catch (Exception ex)
         {
@@ -112,14 +131,14 @@ private void BuildGrid(IReadOnlyDictionary<DateTime, DayActivity> activity, int
     private Task PrevMonthAsync()
     {
         Shift(-1);
-        return LoadAsync(CancellationToken.None);
+        return ShowMonthAsync(CancellationToken.None); // cached
     }
 
     [RelayCommand]
     private Task NextMonthAsync()
     {
         Shift(1);
-        return LoadAsync(CancellationToken.None);
+        return ShowMonthAsync(CancellationToken.None); // cached
     }
 
     private void Shift(int months)

src/OpenIPC.Viewer.App/ViewModels/RecordingPlayerPageViewModel.cs

@@ -34,6 +34,7 @@ public sealed partial class RecordingPlayerPageViewModel : ViewModelBase, IAsync
     private readonly IEventRepository _events;
     private readonly IClipExporter _exporter;
     private readonly IDialogService _dialogs;
+    private readonly OpenIPC.Viewer.Core.Platform.IShareService _share;
     private readonly ILogger<RecordingPlayerPageViewModel> _logger;
 
     private IPlaybackSession? _playback;
@@ -50,6 +51,7 @@ public RecordingPlayerPageViewModel(
         IEventRepository events,
         IClipExporter exporter,
         IDialogService dialogs,
+        OpenIPC.Viewer.Core.Platform.IShareService share,
         ILogger<RecordingPlayerPageViewModel> logger)
     {
         _recording = recording;
@@ -59,6 +61,7 @@ public RecordingPlayerPageViewModel(
         _events = events;
         _exporter = exporter;
         _dialogs = dialogs;
+        _share = share;
         _logger = logger;
 
         // Timeline starts as the single recording's span; refined once the exact
@@ -280,6 +283,11 @@ private async Task ExportAsync()
             var progress = new Progress<double>(p => ExportFraction = p);
             await _exporter.ExportAsync(request, progress, CancellationToken.None).ConfigureAwait(true);
             ExportStatus = Path.GetFileName(dest);
+
+            // On mobile the picked file is invisible to the user, so hand the
+            // clip to the native share sheet (Phase 16.5 "в галерею/share").
+            if (_share.SupportsSystemShare)
+                await _share.ShareFileAsync(dest!, "video/mp4", CancellationToken.None).ConfigureAwait(true);
         }
         catch (Exception ex)
         {

tests/OpenIPC.Viewer.Video.Tests/ClipExportIntegrationTests.cs

@@ -0,0 +1,71 @@
+using System.IO;
+using Microsoft.Extensions.Logging.Abstractions;
+using OpenIPC.Viewer.Core.Archive;
+using OpenIPC.Viewer.Core.Entities;
+using OpenIPC.Viewer.Core.Recording;
+using OpenIPC.Viewer.Core.Video;
+using OpenIPC.Viewer.Video.Pipeline;
+using OpenIPC.Viewer.Video.Recording;
+
+namespace OpenIPC.Viewer.Video.Tests;
+
+// Phase 16.7 integration: record a few seconds (in-process libav, the mobile
+// path) → probe the file → export an in/out range → probe the clip. Verifies
+// the probe reports a real duration and the clip length ≈ the selection.
+// Gated on the MediaMTX fixture (skips when docker isn't up), like the live
+// session test. Tolerances are loose — this is an end-to-end smoke test.
+public sealed class ClipExportIntegrationTests
+{
+    [SkippableFact]
+    public async Task Record_Probe_Export_RoundTrip()
+    {
+        Skip.IfNot(MediaMtxFixture.IsReachable(),
+            "MediaMTX not running on localhost:8554 — start tools/mediamtx/docker-compose.yml first.");
+
+        var dir = Path.Combine(Path.GetTempPath(), "openipc-cliptest-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(dir);
+        try
+        {
+            // --- Record ~5s ---
+            var recorder = new LibavformatRecorder(NullLoggerFactory.Instance);
+            var options = new RecordingOptions(
+                CameraId: CameraId.New(),
+                RtspUri: new Uri(MediaMtxFixture.TestStreamUri),
+                Credentials: null,
+                OutputDirectory: dir,
+                FilenamePattern: "rec.mp4",
+                SegmentDuration: TimeSpan.FromMinutes(10));
+
+            var session = await recorder.StartAsync(options, CancellationToken.None);
+            await Task.Delay(TimeSpan.FromSeconds(5));
+            var sourcePath = session.CurrentSegmentPath;
+            await session.StopAsync(CancellationToken.None);
+            await session.DisposeAsync();
+
+            Assert.False(string.IsNullOrEmpty(sourcePath), "Recorder produced no file path");
+            Assert.True(File.Exists(sourcePath), $"Recorded file missing: {sourcePath}");
+
+            // --- Probe the recording ---
+            var probe = new FfmpegMediaProbe(NullLogger<FfmpegMediaProbe>.Instance);
+            var srcInfo = await probe.ProbeAsync(sourcePath!, CancellationToken.None);
+            Assert.InRange(srcInfo.Duration.TotalSeconds, 1.5, 15.0);
+
+            // --- Export [1s, 3s] (stream copy) ---
+            var clipPath = Path.Combine(dir, "clip.mp4");
+            var exporter = new LibavformatClipExporter(NullLoggerFactory.Instance);
+            await exporter.ExportAsync(
+                new ClipExportRequest(sourcePath!, clipPath, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(3), Precise: false),
+                progress: null, CancellationToken.None);
+
+            Assert.True(File.Exists(clipPath), "Exported clip missing");
+
+            // --- Probe the clip: ~2s ± GOP slack ---
+            var clipInfo = await probe.ProbeAsync(clipPath, CancellationToken.None);
+            Assert.InRange(clipInfo.Duration.TotalSeconds, 0.3, 5.0);
+        }
+        finally
+        {
+            try { Directory.Delete(dir, recursive: true); } catch { /* best effort */ }
+        }
+    }
+}