First working POC

src-tauri/src/commands/playback_reporting.rs

@@ -0,0 +1,184 @@
+//! Tauri commands for playback reporting operations
+//!
+//! These commands provide frontend access to the Rust playback reporting system,
+//! replacing the TypeScript implementation with native Rust reporting.
+//!
+//! Commands are registered but not yet called from the frontend.
+//! Dead code warnings are suppressed until frontend migration is complete.
+
+#![allow(dead_code)]
+
+use std::sync::Arc;
+use tauri::State;
+use tokio::sync::Mutex as TokioMutex;
+
+use crate::commands::connectivity::ConnectivityMonitorWrapper;
+use crate::commands::storage::DatabaseWrapper;
+use crate::jellyfin::client::JellyfinClient;
+use crate::jellyfin::JellyfinConfig;
+use crate::playback_reporting::{PlaybackReporter, PlaybackOperation, PlaybackContext};
+use crate::utils::conversions::seconds_to_ticks;
+
+/// Tauri state wrapper for PlaybackReporter
+pub struct PlaybackReporterWrapper(pub Arc<TokioMutex<Option<PlaybackReporter>>>);
+
+/// Initialize playback reporter (called after login)
+#[tauri::command]
+pub async fn playback_reporter_init(
+    reporter_wrapper: State<'_, PlaybackReporterWrapper>,
+    db: State<'_, DatabaseWrapper>,
+    server_url: String,
+    user_id: String,
+    access_token: String,
+    device_id: String,
+) -> Result<(), String> {
+    log::info!("[PlaybackReporter] Initializing for user: {}", user_id);
+
+    // Get database service
+    let db_service = {
+        let database = db.0.lock().map_err(|e| e.to_string())?;
+        Arc::new(database.service())
+    };
+
+    // Create JellyfinClient
+    let jellyfin_config = JellyfinConfig {
+        server_url,
+        access_token,
+        device_id,
+    };
+
+    let jellyfin_client = JellyfinClient::new(jellyfin_config)
+        .map_err(|e| format!("Failed to create JellyfinClient: {}", e))?;
+
+    // Create PlaybackReporter
+    let reporter = PlaybackReporter::new(
+        db_service,
+        Arc::new(TokioMutex::new(Some(jellyfin_client))),
+        user_id.clone(),
+    );
+
+    // Store in wrapper
+    *reporter_wrapper.0.lock().await = Some(reporter);
+
+    log::info!("[PlaybackReporter] Initialized successfully for user: {}", user_id);
+    Ok(())
+}
+
+/// Destroy playback reporter (called on logout)
+#[tauri::command]
+pub async fn playback_reporter_destroy(
+    reporter_wrapper: State<'_, PlaybackReporterWrapper>,
+) -> Result<(), String> {
+    log::info!("[PlaybackReporter] Destroying reporter");
+    *reporter_wrapper.0.lock().await = None;
+    Ok(())
+}
+
+/// Report playback start
+#[tauri::command]
+pub async fn playback_report_start(
+    reporter: State<'_, PlaybackReporterWrapper>,
+    connectivity: State<'_, ConnectivityMonitorWrapper>,
+    item_id: String,
+    position_seconds: f64,
+    context_type: Option<String>,
+    context_id: Option<String>,
+) -> Result<(), String> {
+    let reporter_guard = reporter.0.lock().await;
+    let reporter_instance = reporter_guard
+        .as_ref()
+        .ok_or("PlaybackReporter not initialized")?;
+
+    let position_ticks = seconds_to_ticks(position_seconds);
+    let context = context_type.map(|ct| PlaybackContext {
+        context_type: ct,
+        context_id,
+    });
+
+    let operation = PlaybackOperation::Start {
+        item_id,
+        position_ticks,
+        context,
+    };
+
+    let monitor = connectivity.0.lock().await;
+    let is_online = monitor.get_status().await.is_server_reachable;
+    drop(monitor);
+
+    reporter_instance.report(operation, is_online).await
+}
+
+/// Report playback progress
+#[tauri::command]
+pub async fn playback_report_progress(
+    reporter: State<'_, PlaybackReporterWrapper>,
+    connectivity: State<'_, ConnectivityMonitorWrapper>,
+    item_id: String,
+    position_seconds: f64,
+    is_paused: bool,
+) -> Result<(), String> {
+    let reporter_guard = reporter.0.lock().await;
+    let reporter_instance = reporter_guard
+        .as_ref()
+        .ok_or("PlaybackReporter not initialized")?;
+
+    let position_ticks = seconds_to_ticks(position_seconds);
+    let operation = PlaybackOperation::Progress {
+        item_id,
+        position_ticks,
+        is_paused,
+    };
+
+    let monitor = connectivity.0.lock().await;
+    let is_online = monitor.get_status().await.is_server_reachable;
+    drop(monitor);
+
+    reporter_instance.report(operation, is_online).await
+}
+
+/// Report playback stopped
+#[tauri::command]
+pub async fn playback_report_stopped(
+    reporter: State<'_, PlaybackReporterWrapper>,
+    connectivity: State<'_, ConnectivityMonitorWrapper>,
+    item_id: String,
+    position_seconds: f64,
+) -> Result<(), String> {
+    let reporter_guard = reporter.0.lock().await;
+    let reporter_instance = reporter_guard
+        .as_ref()
+        .ok_or("PlaybackReporter not initialized")?;
+
+    let position_ticks = seconds_to_ticks(position_seconds);
+    let operation = PlaybackOperation::Stopped {
+        item_id,
+        position_ticks,
+    };
+
+    let monitor = connectivity.0.lock().await;
+    let is_online = monitor.get_status().await.is_server_reachable;
+    drop(monitor);
+
+    reporter_instance.report(operation, is_online).await
+}
+
+/// Mark item as played
+#[tauri::command]
+pub async fn playback_mark_played(
+    reporter: State<'_, PlaybackReporterWrapper>,
+    connectivity: State<'_, ConnectivityMonitorWrapper>,
+    item_id: String,
+) -> Result<(), String> {
+    let reporter_guard = reporter.0.lock().await;
+    let reporter_instance = reporter_guard
+        .as_ref()
+        .ok_or("PlaybackReporter not initialized")?;
+
+    let operation = PlaybackOperation::MarkPlayed { item_id };
+
+    let monitor = connectivity.0.lock().await;
+    let is_online = monitor.get_status().await.is_server_reachable;
+    drop(monitor);
+
+    reporter_instance.report(operation, is_online).await
+}