feat: Integrating update play now API

Author: Losses

Cargo.lock

@@ -4,7 +4,7 @@
 # various Rust configurations.
 
 [workspace]
-members = ["./native/*", "./cli", "lyric", "scrobbling"]
+members = ["./native/*", "./cli"]
 resolver = "2"
 
 [patch.crates-io]

Cargo.toml

@@ -5,10 +5,11 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use anyhow::{bail, Error};
 use anyhow::{Context, Result};
 use log::{debug, error, info};
-use sea_orm::DatabaseConnection;
+use sea_orm::{DatabaseConnection, TransactionTrait};
 use tokio::sync::Mutex;
 use tokio::task;
 
+use database::actions::logging::insert_log;
 use database::actions::playback_queue::replace_playback_queue;
 use database::actions::stats::increase_played_through;
 use database::connection::MainDbConnection;
@@ -29,12 +30,12 @@ use scrobbling::ScrobblingTrack;
 use crate::{CrashResponse, PlaybackStatus, PlaylistItem, PlaylistUpdate, RealtimeFft};
 
 pub fn metadata_summary_to_scrobbling_track(
-    metadata: PlayingItemMetadataSummary,
+    metadata: &PlayingItemMetadataSummary,
 ) -> ScrobblingTrack {
     ScrobblingTrack {
-        artist: metadata.artist,
-        album: Some(metadata.album),
-        track: metadata.title,
+        artist: metadata.artist.clone(),
+        album: Some(metadata.album.clone()),
+        track: metadata.title.clone(),
         duration: Some(metadata.duration.clamp(0.0, u32::MAX as f64) as u32),
         album_artist: None,
         timestamp: Some(
@@ -61,13 +62,17 @@ pub async fn initialize_player(
     let main_db_for_status = Arc::clone(&main_db);
     let main_db_for_played_throudh = Arc::clone(&main_db);
     let main_db_for_playlist = Arc::clone(&main_db);
+    let main_db_for_error_reporter = Arc::clone(&main_db);
 
     let manager = Arc::new(Mutex::new(MediaControlManager::new()?));
 
     let os_controller_receiver = manager.lock().await.subscribe_controller_events();
     let dispatcher = Arc::new(Mutex::new(PlayingItemActionDispatcher::new()));
     let dispatcher_for_played_through = Arc::clone(&dispatcher);
 
+    let scrobber_for_played_through = Arc::clone(&scrobbler);
+    let scrobber_for_error_reporter = Arc::clone(&scrobbler);
+
     manager.lock().await.initialize()?;
 
     info!("Initializing event listeners");
@@ -137,6 +142,9 @@ pub async fn initialize_player(
                                             );
                                         }
                                     };
+
+                                    let track = metadata_summary_to_scrobbling_track(metadata);
+                                    scrobbler.lock().await.update_now_playing_all(track);
                                 }
                                 None => {
                                     error!("No metadata found for: {:?}", item_clone_for_status);
@@ -215,6 +223,7 @@ pub async fn initialize_player(
     task::spawn(async move {
         let main_db = Arc::clone(&main_db_for_played_throudh);
         let dispatcher = Arc::clone(&dispatcher_for_played_through);
+        let scrobbler = Arc::clone(&scrobber_for_played_through);
 
         while let Ok(item) = played_through_receiver.recv().await {
             match item {
@@ -242,7 +251,7 @@ pub async fn initialize_player(
                 }
 
                 let metadata: PlayingItemMetadataSummary = metadata[0].clone();
-                let track: ScrobblingTrack = metadata_summary_to_scrobbling_track(metadata);
+                let track: ScrobblingTrack = metadata_summary_to_scrobbling_track(&metadata);
 
                 scrobbler.lock().await.scrobble_all(track);
             }
@@ -255,6 +264,41 @@ pub async fn initialize_player(
         }
     });
 
+    task::spawn(async move {
+        let main_db = Arc::clone(&main_db_for_error_reporter);
+
+        let scrobbler = Arc::clone(&scrobber_for_error_reporter);
+        let error_receiver = scrobbler.lock().await.subscribe_error();
+
+        while let Ok(error) = error_receiver.recv().await {
+            error!(
+                "Scrobbler received error: {:?}::{:?}: {:#?}",
+                error.service, error.action, error.error
+            );
+
+            match main_db.begin().await {
+                Ok(txn) => {
+                    if let Err(e) = insert_log(
+                        &txn,
+                        database::actions::logging::LogLevel::Error,
+                        format!("scrobbler::{:?}::{:?}", error.action, error.service),
+                        format!("{:#?}", error),
+                    )
+                    .await
+                    {
+                        error!("Failed to log scrobbler error: {:#?}", e);
+                    }
+                }
+                Err(e) => {
+                    error!(
+                        "Failed to start txn while logging scrobbler error: {:#?}",
+                        e
+                    );
+                }
+            }
+        }
+    });
+
     task::spawn(async move {
         let player = Arc::clone(&player);
 

native/hub/src/player.rs

@@ -41,11 +41,11 @@ windows = { version = "0.44.0", features = [
     "Win32_Graphics_Gdi",
 ] }
 once_cell = "1.20.2"
+simple_channel = { path = "../simple-channel" }
 
 [target.'cfg(not(target_os = "android"))'.dependencies]
 souvlaki = "0.7.3"
 
 [target.'cfg(target_os = "android")'.dependencies]
 ndk-context = "0.1.1"
 jni = "0.21.1"
-

playback/Cargo.toml

@@ -11,13 +11,14 @@ use std::{
 use anyhow::{bail, Error, Result};
 use log::{debug, info};
 use once_cell::sync::OnceCell;
+use tokio::sync::Mutex;
 
 #[cfg(target_os = "android")]
 use crate::dummy_souvlaki::{MediaControlEvent, MediaControls, PlatformConfig, SeekDirection};
-use crate::simple_channel::{SimpleChannel, SimpleReceiver, SimpleSender};
 #[cfg(not(target_os = "android"))]
 use souvlaki::{MediaControlEvent, MediaControls, PlatformConfig, SeekDirection};
-use tokio::sync::Mutex;
+
+use simple_channel::{SimpleChannel, SimpleReceiver, SimpleSender};
 
 use crate::player::{PlaybackState, Player};
 

playback/src/controller.rs

@@ -2,7 +2,6 @@ mod internal;
 mod realtime_fft;
 mod sfx_internal;
 mod shared_source;
-mod simple_channel;
 
 pub mod buffered;
 pub mod controller;

playback/src/lib.rs

@@ -4,11 +4,11 @@ use std::time::Duration;
 use std::{fmt, thread};
 
 use log::{debug, error};
+use simple_channel::{SimpleChannel, SimpleReceiver, SimpleSender};
 use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
 
 use crate::internal::{PlaybackMode, PlayerCommand, PlayerEvent, PlayerInternal};
-use crate::simple_channel::{SimpleChannel, SimpleReceiver, SimpleSender};
 use crate::strategies::AddMode;
 
 #[derive(Debug, Clone)]

playback/src/player.rs

@@ -3,7 +3,7 @@ use std::thread;
 
 use rustfft::{num_complex::Complex, FftPlanner};
 
-use crate::simple_channel::{SimpleChannel, SimpleReceiver, SimpleSender};
+use simple_channel::{SimpleChannel, SimpleReceiver, SimpleSender};
 
 pub struct RealTimeFFT {
     window_size: usize,

playback/src/realtime_fft.rs

@@ -16,6 +16,7 @@ reqwest = { version = "0.12.9", features = ["blocking", "json", "socks"] }
 serde = "1.0.216"
 serde_json = "1.0.133"
 tokio = { version = "1.42.0" }
+simple_channel = { path = "../simple-channel" }
 
 [dev-dependencies]
 clap = "4.5.9"