Add VideoWall feature: server-side preview clip generation and mobile grid view

Backend (Rust/Actix-web):
- Add video_preview_clips table and PreviewDao for tracking preview generation
- Add ffmpeg preview clip generator: 10 equally-spaced 1s segments at 480p with CUDA NVENC auto-detection
- Add PreviewClipGenerator actor with semaphore-limited concurrent processing
- Add GET /video/preview and POST /video/preview/status endpoints
- Extend file watcher to detect and queue previews for new videos
- Use relative paths consistently for DB storage (matching EXIF convention)

Frontend (React Native/Expo):
- Add VideoWall grid view with 2-3 column layout of looping preview clips
- Add VideoWallItem component with ActiveVideoPlayer sub-component for lifecycle management
- Add useVideoWall hook for batch status polling with 5s refresh
- Add navigation button in grid header (visible when videos exist)
- Use TextureView surface type to fix Android z-ordering issues
- Optimize memory: players only mount while visible via FlatList windowSize
- Configure ExoPlayer buffer options and caching for short clips
- Tap to toggle audio focus, long press to open in full viewer

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/database/preview_dao.rs

@@ -0,0 +1,183 @@
+use diesel::prelude::*;
+use diesel::sqlite::SqliteConnection;
+use std::ops::DerefMut;
+use std::sync::{Arc, Mutex};
+
+use crate::database::models::{InsertVideoPreviewClip, VideoPreviewClip};
+use crate::database::{connect, DbError, DbErrorKind};
+use crate::otel::trace_db_call;
+
+pub trait PreviewDao: Sync + Send {
+    fn insert_preview(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_path_val: &str,
+        status_val: &str,
+    ) -> Result<(), DbError>;
+
+    fn update_status(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_path_val: &str,
+        status_val: &str,
+        duration: Option<f32>,
+        size: Option<i32>,
+        error: Option<&str>,
+    ) -> Result<(), DbError>;
+
+    fn get_preview(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_path_val: &str,
+    ) -> Result<Option<VideoPreviewClip>, DbError>;
+
+    fn get_previews_batch(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_paths: &[String],
+    ) -> Result<Vec<VideoPreviewClip>, DbError>;
+
+    fn get_by_status(
+        &mut self,
+        context: &opentelemetry::Context,
+        status_val: &str,
+    ) -> Result<Vec<VideoPreviewClip>, DbError>;
+}
+
+pub struct SqlitePreviewDao {
+    connection: Arc<Mutex<SqliteConnection>>,
+}
+
+impl Default for SqlitePreviewDao {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SqlitePreviewDao {
+    pub fn new() -> Self {
+        SqlitePreviewDao {
+            connection: Arc::new(Mutex::new(connect())),
+        }
+    }
+}
+
+impl PreviewDao for SqlitePreviewDao {
+    fn insert_preview(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_path_val: &str,
+        status_val: &str,
+    ) -> Result<(), DbError> {
+        trace_db_call(context, "insert", "insert_preview", |_span| {
+            use crate::database::schema::video_preview_clips::dsl::*;
+
+            let mut connection = self.connection.lock().expect("Unable to get PreviewDao");
+            let now = chrono::Utc::now().to_rfc3339();
+
+            diesel::insert_or_ignore_into(video_preview_clips)
+                .values(InsertVideoPreviewClip {
+                    file_path: file_path_val.to_string(),
+                    status: status_val.to_string(),
+                    created_at: now.clone(),
+                    updated_at: now,
+                })
+                .execute(connection.deref_mut())
+                .map(|_| ())
+                .map_err(|e| anyhow::anyhow!("Insert error: {}", e))
+        })
+        .map_err(|_| DbError::new(DbErrorKind::InsertError))
+    }
+
+    fn update_status(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_path_val: &str,
+        status_val: &str,
+        duration: Option<f32>,
+        size: Option<i32>,
+        error: Option<&str>,
+    ) -> Result<(), DbError> {
+        trace_db_call(context, "update", "update_preview_status", |_span| {
+            use crate::database::schema::video_preview_clips::dsl::*;
+
+            let mut connection = self.connection.lock().expect("Unable to get PreviewDao");
+            let now = chrono::Utc::now().to_rfc3339();
+
+            diesel::update(video_preview_clips.filter(file_path.eq(file_path_val)))
+                .set((
+                    status.eq(status_val),
+                    duration_seconds.eq(duration),
+                    file_size_bytes.eq(size),
+                    error_message.eq(error),
+                    updated_at.eq(&now),
+                ))
+                .execute(connection.deref_mut())
+                .map(|_| ())
+                .map_err(|e| anyhow::anyhow!("Update error: {}", e))
+        })
+        .map_err(|_| DbError::new(DbErrorKind::UpdateError))
+    }
+
+    fn get_preview(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_path_val: &str,
+    ) -> Result<Option<VideoPreviewClip>, DbError> {
+        trace_db_call(context, "query", "get_preview", |_span| {
+            use crate::database::schema::video_preview_clips::dsl::*;
+
+            let mut connection = self.connection.lock().expect("Unable to get PreviewDao");
+
+            match video_preview_clips
+                .filter(file_path.eq(file_path_val))
+                .first::<VideoPreviewClip>(connection.deref_mut())
+            {
+                Ok(clip) => Ok(Some(clip)),
+                Err(diesel::result::Error::NotFound) => Ok(None),
+                Err(e) => Err(anyhow::anyhow!("Query error: {}", e)),
+            }
+        })
+        .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
+
+    fn get_previews_batch(
+        &mut self,
+        context: &opentelemetry::Context,
+        file_paths: &[String],
+    ) -> Result<Vec<VideoPreviewClip>, DbError> {
+        trace_db_call(context, "query", "get_previews_batch", |_span| {
+            use crate::database::schema::video_preview_clips::dsl::*;
+
+            if file_paths.is_empty() {
+                return Ok(Vec::new());
+            }
+
+            let mut connection = self.connection.lock().expect("Unable to get PreviewDao");
+
+            video_preview_clips
+                .filter(file_path.eq_any(file_paths))
+                .load::<VideoPreviewClip>(connection.deref_mut())
+                .map_err(|e| anyhow::anyhow!("Query error: {}", e))
+        })
+        .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
+
+    fn get_by_status(
+        &mut self,
+        context: &opentelemetry::Context,
+        status_val: &str,
+    ) -> Result<Vec<VideoPreviewClip>, DbError> {
+        trace_db_call(context, "query", "get_previews_by_status", |_span| {
+            use crate::database::schema::video_preview_clips::dsl::*;
+
+            let mut connection = self.connection.lock().expect("Unable to get PreviewDao");
+
+            video_preview_clips
+                .filter(status.eq(status_val))
+                .load::<VideoPreviewClip>(connection.deref_mut())
+                .map_err(|e| anyhow::anyhow!("Query error: {}", e))
+        })
+        .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
+}