+4 -24

Cargo.lock

reviewed

··· 162 162 source = "registry+https://github.com/rust-lang/crates.io-index" 163 163 checksum = "24eda4e2a6e042aa4e55ac438a2ae052d3b5da0ecf83d7411e1a368946925208" 164 164 dependencies = [ 165 165 + "actix-macros", 165 166 "futures-core", 166 167 "tokio", 167 168 ] ··· 8563 8564 ] 8564 8565 8565 8566 [[package]] 8566 8566 - name = "queryst" 8567 8567 - version = "3.0.0" 8568 8568 - source = "registry+https://github.com/rust-lang/crates.io-index" 8569 8569 - checksum = "c1cbeb75ac695daf201ca2d66d9c684f873b135f28af4f2c79952478cab3b9d9" 8570 8570 - dependencies = [ 8571 8571 - "lazy_static", 8572 8572 - "percent-encoding", 8573 8573 - "regex", 8574 8574 - "serde", 8575 8575 - "serde_json", 8576 8576 - ] 8577 8577 - 8578 8578 - [[package]] 8579 8567 name = "quick-error" 8580 8568 version = "1.2.3" 8581 8569 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 9477 9465 name = "rockbox-server" 9478 9466 version = "0.1.0" 9479 9467 dependencies = [ 9468 9468 + "actix-cors", 9469 9469 + "actix-rt", 9470 9470 + "actix-web", 9480 9471 "anyhow", 9481 9472 "async-std", 9482 9473 "futures-util", ··· 9485 9476 "md5", 9486 9477 "netstream", 9487 9478 "owo-colors 4.1.0", 9488 9488 - "queryst", 9489 9479 "rand 0.8.5", 9490 9480 "reqwest", 9491 9481 "rockbox-bluetooth", ··· 9510 9500 "serde", 9511 9501 "serde_json", 9512 9502 "sqlx", 9513 9513 - "threadpool", 9514 9503 "tokio", 9515 9504 "tracing", 9516 9505 "url", ··· 11703 11692 dependencies = [ 11704 11693 "cfg-if 1.0.0", 11705 11694 "once_cell", 11706 11706 - ] 11707 11707 - 11708 11708 - [[package]] 11709 11709 - name = "threadpool" 11710 11710 - version = "1.8.1" 11711 11711 - source = "registry+https://github.com/rust-lang/crates.io-index" 11712 11712 - checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa" 11713 11713 - dependencies = [ 11714 11714 - "num_cpus", 11715 11695 ] 11716 11696 11717 11697 [[package]]

+242

THREADING.md

reviewed

··· 1 1 + # Rockbox Threading Model & Rust Integration 2 2 + 3 3 + ## Overview 4 4 + 5 5 + Rockboxd has two distinct classes of threads that must coexist: 6 6 + 7 7 + 1. **Rockbox kernel threads** — created via `create_thread()` in C, managed by the Rockbox cooperative scheduler, **must yield explicitly**. 8 8 + 2. **Rust OS threads** — created via `std::thread::spawn`, fully preemptive OS threads, completely independent of the Rockbox scheduler. 9 9 + 10 10 + Understanding the boundary between these two classes is critical. Crossing it incorrectly (e.g. doing a plain OS-level block inside a Rockbox kernel thread) will silently starve every other Rockbox kernel thread. 11 11 + 12 12 + --- 13 13 + 14 14 + ## The SDL Cooperative Scheduler 15 15 + 16 16 + On the `sdlapp` hosted target (macOS / Linux desktop), each Rockbox kernel thread is backed by a real SDL OS thread (`SDL_CreateThread`). However, Rockbox layers a **cooperative scheduler** on top of those OS threads using a single global SDL mutex: 17 17 + 18 18 + ```c 19 19 + // firmware/target/hosted/sdl/thread-sdl.c 20 20 + static SDL_mutex *m; // THE global Rockbox scheduler mutex 21 21 + ``` 22 22 + 23 23 + **Only the thread that holds `m` is considered "running" by the Rockbox kernel.** All other Rockbox kernel threads are blocked in `SDL_LockMutex(m)`. 24 24 + 25 25 + `switch_thread()` is the scheduler's yield primitive: 26 26 + ```c 27 27 + void switch_thread(void) { 28 28 + SDL_UnlockMutex(m); // release the token — let another thread run 29 29 + SDL_LockMutex(m); // re-acquire when it's our turn again 30 30 + } 31 31 + ``` 32 32 + 33 33 + Every Rockbox sleep / block call eventually calls `switch_thread()`, which is the only way to hand the scheduler token to another thread. 34 34 + 35 35 + ### What happens without yielding 36 36 + 37 37 + If a Rockbox kernel thread calls any long-running operation — including a plain Rust `thread::sleep`, `join()`, or a `tokio::block_on` — **without first releasing the mutex via `rb::system::sleep`**, the global mutex is never released. Every other Rockbox kernel thread is stuck forever in `SDL_LockMutex(m)`. 38 38 + 39 39 + ### The yield contract 40 40 + 41 41 + Any code running in a Rockbox kernel thread that may block for more than a few milliseconds must include a yield loop: 42 42 + 43 43 + ```rust 44 44 + loop { 45 45 + thread::sleep(std::time::Duration::from_millis(100)); // OS-level rest 46 46 + rb::system::sleep(rb::HZ); // release Rockbox mutex 47 47 + } 48 48 + ``` 49 49 + 50 50 + `rb::HZ` is 100 (ticks per second on the hosted target), so `sleep(rb::HZ)` sleeps for ~1 second and releases the mutex for that duration. 51 51 + 52 52 + ### Stack size note 53 53 + 54 54 + The `stack` and `stack_size` arguments to `create_thread()` are **ignored** on the SDL hosted target (see `thread-sdl.c`: `(void)stack; (void)stack_size;`). SDL threads receive the OS default stack size (typically 8 MB on macOS). Stack overflow is not a concern on hosted. 55 55 + 56 56 + --- 57 57 + 58 58 + ## Thread Map 59 59 + 60 60 + ### Rockbox kernel threads (must yield) 61 61 + 62 62 + | Thread | C entry point | What it does | 63 63 + |--------|---------------|--------------| 64 64 + | `server_thread` | `server_thread.c` → `start_server()` | Spawns the actix HTTP server in a Rust OS thread, then loops yielding to the Rockbox scheduler | 65 65 + | `broker_thread` | `broker_thread.c` → `start_broker()` | Event loop: publishes playback state to GraphQL subscriptions, scrobbles tracks, restores playlist | 66 66 + 67 67 + Both threads must call `rb::system::sleep(rb::HZ)` on every loop iteration. 68 68 + 69 69 + **`server_thread` pattern** (`crates/server/src/lib.rs`): 70 70 + ```rust 71 71 + pub extern "C" fn start_server() { 72 72 + rockbox_settings::load_settings(None).ok(); 73 73 + rockbox_upnp::init(); 74 74 + 75 75 + // Spawn HTTP server in its own Rust OS thread — does NOT hold the 76 76 + // Rockbox mutex, so it can block freely in actix/tokio. 77 77 + thread::spawn(|| { 78 78 + match actix_rt::System::new().block_on(run_http_server()) { ... } 79 79 + }); 80 80 + 81 81 + // Keep the Rockbox kernel thread alive and cooperative. 82 82 + loop { 83 83 + thread::sleep(std::time::Duration::from_millis(100)); 84 84 + rb::system::sleep(rb::HZ); 85 85 + } 86 86 + } 87 87 + ``` 88 88 + 89 89 + **`broker_thread` pattern** (`crates/server/src/lib.rs`): 90 90 + ```rust 91 91 + pub extern "C" fn start_broker() { 92 92 + // ... setup ... 93 93 + loop { 94 94 + // ... do work (check playback, publish events) ... 95 95 + thread::sleep(std::time::Duration::from_millis(100)); 96 96 + rb::system::sleep(rb::HZ); // yield the Rockbox mutex 97 97 + } 98 98 + } 99 99 + ``` 100 100 + 101 101 + ### Rust OS threads (no Rockbox scheduler involvement) 102 102 + 103 103 + These are spawned with `std::thread::spawn` — they are pure OS threads and never interact with the Rockbox mutex. They are free to block indefinitely. 104 104 + 105 105 + | Thread / component | Spawned from | Runtime | 106 106 + |--------------------|--------------|---------| 107 107 + | **HTTP server** (actix-web, port 6063) | `start_server()` via `thread::spawn` | `actix_rt::System` (single-thread + LocalSet per arbiter) | 108 108 + | **gRPC server** (tonic, port 6061) | `start_servers()` via `thread::spawn` | `tokio::Builder::new_current_thread` | 109 109 + | **GraphQL server** (async-graphql, port 6062) | `start_servers()` via `thread::spawn` | `tokio::Builder::new_current_thread` | 110 110 + | **MPD server** (port 6600) | `start_servers()` via `thread::spawn` | `tokio::Builder::new_current_thread` | 111 111 + | **MPRIS server** (Linux, D-Bus) | `start_servers()` via `thread::spawn` | `async_std` task | 112 112 + | **UPnP runtime** | `rockbox_upnp::init()` (static `OnceLock`) | `tokio::runtime::Runtime::new()` (multi-thread) | 113 113 + | **Device scanners** (Chromecast, AirPlay, Snapcast, UPnP, Squeezelite) | `run_http_server()` via `thread::spawn` | each creates its own `tokio::runtime::Runtime::new()` | 114 114 + | **Player event listener** | `run_http_server()` via `thread::spawn` | `tokio::runtime::Runtime::new()` (multi-thread) | 115 115 + | **Command relay** | `start_servers()` via `thread::spawn` | `reqwest::blocking` (creates its own tokio internally) | 116 116 + 117 117 + --- 118 118 + 119 119 + ## Startup Sequence 120 120 + 121 121 + ``` 122 122 + main.c: server_init() 123 123 + │ 124 124 + ├── create_thread(server_thread) ← Rockbox kernel thread 125 125 + │ └── start_server() 126 126 + │ ├── load_settings() 127 127 + │ ├── rockbox_upnp::init() ← creates static UPnP multi-thread runtime 128 128 + │ ├── thread::spawn(actix) ← Rust OS thread (free to block) 129 129 + │ └── loop { sleep + rb::system::sleep(HZ) } ← yields Rockbox mutex 130 130 + │ 131 131 + ├── sleep(HZ) ← Rockbox scheduler sleep on main thread (~1 s) 132 132 + │ 133 133 + └── start_servers() ← called on main C thread after 1 s 134 134 + ├── thread::spawn(gRPC server) ← Rust OS thread, new_current_thread runtime 135 135 + ├── thread::spawn(GraphQL server) ← Rust OS thread, new_current_thread runtime 136 136 + ├── thread::spawn(MPD server) ← Rust OS thread, new_current_thread runtime 137 137 + ├── thread::spawn(MPRIS, Linux) ← Rust OS thread, async_std 138 138 + └── thread::spawn(command relay) ← Rust OS thread, reqwest blocking 139 139 + 140 140 + main.c: broker_init() 141 141 + │ 142 142 + └── create_thread(broker_thread) ← Rockbox kernel thread 143 143 + └── start_broker() 144 144 + └── loop { work + sleep + rb::system::sleep(HZ) } 145 145 + ``` 146 146 + 147 147 + --- 148 148 + 149 149 + ## Tokio Runtime Layout 150 150 + 151 151 + Multiple independent tokio runtimes coexist; they do not share thread pools or event loops. 152 152 + 153 153 + ``` 154 154 + ┌─────────────────────────────────────────────────────┐ 155 155 + │ UPnP Runtime (static, multi-thread) │ 156 156 + │ Owns: mDNS/SSDP, UPnP HTTP, UPnP renderer │ 157 157 + └─────────────────────────────────────────────────────┘ 158 158 + 159 159 + ┌─────────────────────────────────────────────────────┐ 160 160 + │ actix-rt System (current-thread + LocalSet) │ 161 161 + │ Owns: HTTP REST API handlers (port 6063) │ 162 162 + │ Workers: actix arbiters, each on their own thread │ 163 163 + └─────────────────────────────────────────────────────┘ 164 164 + 165 165 + ┌─────────────────────────────────────────────────────┐ 166 166 + │ gRPC Runtime (current-thread) │ 167 167 + │ Owns: tonic server (port 6061) │ 168 168 + └─────────────────────────────────────────────────────┘ 169 169 + 170 170 + ┌─────────────────────────────────────────────────────┐ 171 171 + │ GraphQL Runtime (current-thread) │ 172 172 + │ Owns: async-graphql + subscriptions (port 6062) │ 173 173 + └─────────────────────────────────────────────────────┘ 174 174 + 175 175 + ┌─────────────────────────────────────────────────────┐ 176 176 + │ MPD Runtime (current-thread) │ 177 177 + │ Owns: MPD protocol server (port 6600) │ 178 178 + └─────────────────────────────────────────────────────┘ 179 179 + 180 180 + ┌─────────────────────────────────────────────────────┐ 181 181 + │ Scanner / player-event runtimes (multi-thread each)│ 182 182 + │ Short-lived, one per background scanning thread │ 183 183 + └─────────────────────────────────────────────────────┘ 184 184 + ``` 185 185 + 186 186 + All runtimes share a single **SQLite database** (`~/.config/rockbox.org/rockbox-library.db`). The connection pool is configured with: 187 187 + - WAL journal mode (concurrent readers + one writer) 188 188 + - `busy_timeout = 30 s` (serialize concurrent writers instead of failing) 189 189 + 190 190 + --- 191 191 + 192 192 + ## Rules & Pitfalls 193 193 + 194 194 + ### Rule 1: Never do a plain OS block inside a Rockbox kernel thread 195 195 + 196 196 + Wrong — starves every other Rockbox thread: 197 197 + ```rust 198 198 + pub extern "C" fn start_server() { 199 199 + let rt = tokio::runtime::Builder::new_current_thread().build().unwrap(); 200 200 + rt.block_on(run_server()); // WRONG: holds Rockbox mutex, nothing else runs 201 201 + } 202 202 + ``` 203 203 + 204 204 + Wrong — same problem: 205 205 + ```rust 206 206 + let handle = thread::spawn(|| { run_server() }); 207 207 + handle.join().unwrap(); // WRONG: OS-level block, Rockbox mutex never released 208 208 + ``` 209 209 + 210 210 + Correct — spawn work out, yield in the Rockbox thread: 211 211 + ```rust 212 212 + thread::spawn(|| { run_server() }); 213 213 + loop { 214 214 + thread::sleep(Duration::from_millis(100)); 215 215 + rb::system::sleep(rb::HZ); // releases Rockbox mutex 216 216 + } 217 217 + ``` 218 218 + 219 219 + ### Rule 2: Use `actix_rt::System` for the HTTP server, not a raw tokio runtime 220 220 + 221 221 + Wrong — actix detects "existing Tokio runtime" and collapses all workers onto one thread: 222 222 + ```rust 223 223 + let rt = tokio::runtime::Builder::new_current_thread().build().unwrap(); 224 224 + rt.block_on(HttpServer::new(...).run()); // "starting in existing Tokio runtime" 225 225 + ``` 226 226 + 227 227 + Correct: 228 228 + ```rust 229 229 + actix_rt::System::new().block_on(run_http_server()); 230 230 + ``` 231 231 + 232 232 + ### Rule 3: Never call `tokio::runtime::Runtime::new()` from inside an active `block_on` 233 233 + 234 234 + Calling `Runtime::new()` from within a `block_on` context (e.g. inside an async actix handler) panics in tokio 1.27+. This is why `rockbox_upnp::init()` is called **before** any runtime is started in `start_server()`. 235 235 + 236 236 + ### Rule 4: `reqwest::blocking` creates its own tokio runtime internally 237 237 + 238 238 + The command-relay thread in `start_servers()` uses `reqwest::blocking::Client`. This internally creates a multi-thread tokio runtime. It must run in a plain Rust OS thread, never inside an existing async context. 239 239 + 240 240 + ### Rule 5: `SimpleBroker` is runtime-agnostic 241 241 + 242 242 + `rockbox_graphql::simplebroker::SimpleBroker` uses `futures_channel::mpsc::UnboundedSender` for pub/sub. `publish()` is a synchronous call — it does not require or interact with any tokio runtime. It is safe to call from any thread, including Rockbox kernel threads and scanner threads with their own runtimes.

+11 -9

crates/library/src/lib.rs

reviewed

··· 1 1 use std::env; 2 2 3 3 use sqlx::{sqlite::SqliteConnectOptions, Error, Executor, Pool, Sqlite, SqlitePool}; 4 4 + use tracing::{debug, warn}; 4 5 5 6 pub mod album_art; 6 7 pub mod artists; ··· 16 17 std::fs::create_dir_all(&rockbox_dir).unwrap(); 17 18 let rockbox_db_path = format!("{}/rockbox-library.db", rockbox_dir); 18 19 let db_url = env::var("DATABASE_URL").unwrap_or(rockbox_db_path); 19 19 - println!("db url {}", db_url); 20 20 + debug!("db url {}", db_url); 20 21 env::set_var("DATABASE_URL", &db_url); 21 22 let options = SqliteConnectOptions::new() 22 23 .filename(db_url) 23 23 - .create_if_missing(true); 24 24 + .create_if_missing(true) 25 25 + .busy_timeout(std::time::Duration::from_secs(30)); 24 26 let pool = SqlitePool::connect_with(options).await?; 25 27 pool.execute(include_str!( 26 28 "../migrations/20240923093823_create_tables.sql" ··· 33 35 .await 34 36 { 35 37 Ok(_) => {} 36 36 - Err(_) => println!("artist_id column already exists"), 38 38 + Err(_) => warn!("artist_id column already exists"), 37 39 } 38 40 39 41 match pool ··· 43 45 .await 44 46 { 45 47 Ok(_) => {} 46 46 - Err(_) => println!("album_id column already exists"), 48 48 + Err(_) => warn!("album_id column already exists"), 47 49 } 48 50 match pool 49 51 .execute(include_str!( ··· 52 54 .await 53 55 { 54 56 Ok(_) => {} 55 55 - Err(_) => println!("label column already exists"), 57 57 + Err(_) => warn!("label column already exists"), 56 58 } 57 59 58 60 match pool ··· 62 64 .await 63 65 { 64 66 Ok(_) => {} 65 65 - Err(_) => println!("copyright_message column already exists"), 67 67 + Err(_) => warn!("copyright_message column already exists"), 66 68 } 67 69 68 70 match pool ··· 72 74 .await 73 75 { 74 76 Ok(_) => {} 75 75 - Err(_) => println!("genres column already exists"), 77 77 + Err(_) => warn!("genres column already exists"), 76 78 } 77 79 78 80 match pool ··· 82 84 .await 83 85 { 84 86 Ok(_) => {} 85 85 - Err(_) => println!("playlist tables already exist"), 87 87 + Err(_) => warn!("playlist tables already exist"), 86 88 } 87 89 88 90 match pool ··· 92 94 .await 93 95 { 94 96 Ok(_) => {} 95 95 - Err(_) => println!("is_remote column already exists"), 97 97 + Err(_) => warn!("is_remote column already exists"), 96 98 } 97 99 98 100 pool.execute(include_str!(

+3 -2

crates/server/Cargo.toml

reviewed

··· 14 14 local-ip-addr = "0.1.1" 15 15 md5 = "0.7.0" 16 16 owo-colors = "4.0.0" 17 17 - queryst = "3.0.0" 18 17 rand = "0.8.5" 19 18 reqwest = {version = "0.12.5", features = ["blocking", "rustls-tls"], default-features = false} 19 19 + actix-web = "4" 20 20 + actix-rt = "2" 21 21 + actix-cors = "0.7" 20 22 rockbox-chromecast = {path = "../chromecast"} 21 23 rockbox-slim = {path = "../slim"} 22 24 rockbox-upnp = {path = "../upnp"} ··· 39 41 serde = {version = "1.0.210", features = ["derive"]} 40 42 serde_json = "1.0.128" 41 43 sqlx = {version = "0.8.2", features = ["runtime-tokio", "tls-rustls", "sqlite", "chrono", "derive", "macros"]} 42 42 - threadpool = "1.8.1" 43 44 tokio = {version = "1.36.0", features = ["full"]} 44 45 url = "2.3.1" 45 46 urlencoding = "2.1.3"

+10 -6

crates/server/src/cache.rs

reviewed

··· 1 1 - use std::{fs, thread}; 1 1 + use std::{collections::HashMap, fs, sync::Arc, thread}; 2 2 3 3 use anyhow::Error; 4 4 use rockbox_sys::types::tree::Entry; 5 5 + use tokio::sync::Mutex; 5 6 6 6 - use crate::{http::Context, AUDIO_EXTENSIONS}; 7 7 + use crate::AUDIO_EXTENSIONS; 7 8 8 8 - pub fn update_cache(ctx: &Context, path: &str, show_hidden: bool) { 9 9 - let fs_cache = ctx.fs_cache.clone(); 9 9 + pub fn update_cache( 10 10 + fs_cache: Arc<Mutex<HashMap<String, Vec<Entry>>>>, 11 11 + path: &str, 12 12 + show_hidden: bool, 13 13 + ) { 10 14 let path = path.to_string(); 11 15 thread::spawn(move || { 12 16 let mut fs_cache = fs_cache.blocking_lock(); ··· 25 29 continue; 26 30 } 27 31 28 28 - if file.file_name().to_string_lossy().starts_with(".") && !show_hidden { 32 32 + if file.file_name().to_string_lossy().starts_with('.') && !show_hidden { 29 33 continue; 30 34 } 31 35 ··· 44 48 }); 45 49 } 46 50 47 47 - fs_cache.insert(path, entries.clone()); 51 51 + fs_cache.insert(path, entries); 48 52 Ok::<(), Error>(()) 49 53 }); 50 54 }

+21 -17

crates/server/src/handlers/albums.rs

reviewed

··· 1 1 - use anyhow::Error; 1 1 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 2 2 use rockbox_library::repo; 3 3 4 4 - use crate::http::{Context, Request, Response}; 4 4 + use crate::http::AppState; 5 5 6 6 - pub async fn get_albums(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 7 7 - let albums = repo::album::all(ctx.pool.clone()).await?; 8 8 - res.json(&albums); 9 9 - Ok(()) 6 6 + type HandlerResult = actix_web::Result<HttpResponse>; 7 7 + 8 8 + pub async fn get_albums(state: web::Data<AppState>) -> HandlerResult { 9 9 + let albums = repo::album::all(state.pool.clone()) 10 10 + .await 11 11 + .map_err(ErrorInternalServerError)?; 12 12 + Ok(HttpResponse::Ok().json(albums)) 10 13 } 11 14 12 12 - pub async fn get_album(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 13 13 - let album = repo::album::find(ctx.pool.clone(), &req.params[0]).await?; 14 14 - res.json(&album); 15 15 - Ok(()) 15 15 + pub async fn get_album(state: web::Data<AppState>, path: web::Path<String>) -> HandlerResult { 16 16 + let album = repo::album::find(state.pool.clone(), &path.into_inner()) 17 17 + .await 18 18 + .map_err(ErrorInternalServerError)?; 19 19 + Ok(HttpResponse::Ok().json(album)) 16 20 } 17 21 18 22 pub async fn get_album_tracks( 19 19 - ctx: &Context, 20 20 - req: &Request, 21 21 - res: &mut Response, 22 22 - ) -> Result<(), Error> { 23 23 - let tracks = repo::album_tracks::find_by_album(ctx.pool.clone(), &req.params[0]).await?; 24 24 - res.json(&tracks); 25 25 - Ok(()) 23 23 + state: web::Data<AppState>, 24 24 + path: web::Path<String>, 25 25 + ) -> HandlerResult { 26 26 + let tracks = repo::album_tracks::find_by_album(state.pool.clone(), &path.into_inner()) 27 27 + .await 28 28 + .map_err(ErrorInternalServerError)?; 29 29 + Ok(HttpResponse::Ok().json(tracks)) 26 30 }

+28 -24

crates/server/src/handlers/artists.rs

reviewed

··· 1 1 - use anyhow::Error; 1 1 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 2 2 use rockbox_library::repo; 3 3 4 4 - use crate::http::{Context, Request, Response}; 4 4 + use crate::http::AppState; 5 5 + 6 6 + type HandlerResult = actix_web::Result<HttpResponse>; 5 7 6 6 - pub async fn get_artists(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 7 7 - let artists = repo::artist::all(ctx.pool.clone()).await?; 8 8 - res.json(&artists); 9 9 - Ok(()) 8 8 + pub async fn get_artists(state: web::Data<AppState>) -> HandlerResult { 9 9 + let artists = repo::artist::all(state.pool.clone()) 10 10 + .await 11 11 + .map_err(ErrorInternalServerError)?; 12 12 + Ok(HttpResponse::Ok().json(artists)) 10 13 } 11 14 12 12 - pub async fn get_artist(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 13 13 - let artist = repo::artist::find(ctx.pool.clone(), &req.params[0]).await?; 14 14 - res.json(&artist); 15 15 - Ok(()) 15 15 + pub async fn get_artist(state: web::Data<AppState>, path: web::Path<String>) -> HandlerResult { 16 16 + let artist = repo::artist::find(state.pool.clone(), &path.into_inner()) 17 17 + .await 18 18 + .map_err(ErrorInternalServerError)?; 19 19 + Ok(HttpResponse::Ok().json(artist)) 16 20 } 17 21 18 22 pub async fn get_artist_albums( 19 19 - ctx: &Context, 20 20 - req: &Request, 21 21 - res: &mut Response, 22 22 - ) -> Result<(), Error> { 23 23 - let albums = repo::album::find_by_artist(ctx.pool.clone(), &req.params[0]).await?; 24 24 - res.json(&albums); 25 25 - Ok(()) 23 23 + state: web::Data<AppState>, 24 24 + path: web::Path<String>, 25 25 + ) -> HandlerResult { 26 26 + let albums = repo::album::find_by_artist(state.pool.clone(), &path.into_inner()) 27 27 + .await 28 28 + .map_err(ErrorInternalServerError)?; 29 29 + Ok(HttpResponse::Ok().json(albums)) 26 30 } 27 31 28 32 pub async fn get_artist_tracks( 29 29 - ctx: &Context, 30 30 - req: &Request, 31 31 - res: &mut Response, 32 32 - ) -> Result<(), Error> { 33 33 - let tracks = repo::artist_tracks::find_by_artist(ctx.pool.clone(), &req.params[0]).await?; 34 34 - res.json(&tracks); 35 35 - Ok(()) 33 33 + state: web::Data<AppState>, 34 34 + path: web::Path<String>, 35 35 + ) -> HandlerResult { 36 36 + let tracks = repo::artist_tracks::find_by_artist(state.pool.clone(), &path.into_inner()) 37 37 + .await 38 38 + .map_err(ErrorInternalServerError)?; 39 39 + Ok(HttpResponse::Ok().json(tracks)) 36 40 }

+24 -43

crates/server/src/handlers/bluetooth.rs

reviewed

··· 1 1 - use anyhow::Error; 1 1 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 2 2 use rockbox_bluetooth::{connect, disconnect, get_devices, scan}; 3 3 + use serde::Deserialize; 3 4 4 4 - use crate::http::{Context, Request, Response}; 5 5 + type HandlerResult = actix_web::Result<HttpResponse>; 5 6 6 6 - pub async fn scan_bluetooth( 7 7 - _ctx: &Context, 8 8 - req: &Request, 9 9 - res: &mut Response, 10 10 - ) -> Result<(), Error> { 11 11 - let timeout_secs = req.query_params["timeout_secs"] 12 12 - .as_str() 13 13 - .and_then(|s| s.parse::<u64>().ok()) 14 14 - .or_else(|| req.query_params["timeout_secs"].as_u64()) 15 15 - .unwrap_or(10); 7 7 + #[derive(Deserialize)] 8 8 + pub struct ScanQuery { 9 9 + timeout_secs: Option<u64>, 10 10 + } 16 11 17 17 - let devices = scan(timeout_secs).await?; 18 18 - res.json(&devices); 19 19 - Ok(()) 12 12 + pub async fn scan_bluetooth(query: web::Query<ScanQuery>) -> HandlerResult { 13 13 + let timeout_secs = query.timeout_secs.unwrap_or(10); 14 14 + let devices = scan(timeout_secs).await.map_err(ErrorInternalServerError)?; 15 15 + Ok(HttpResponse::Ok().json(devices)) 20 16 } 21 17 22 22 - pub async fn get_bluetooth_devices( 23 23 - _ctx: &Context, 24 24 - _req: &Request, 25 25 - res: &mut Response, 26 26 - ) -> Result<(), Error> { 27 27 - let devices = get_devices().await?; 28 28 - res.json(&devices); 29 29 - Ok(()) 18 18 + pub async fn get_bluetooth_devices() -> HandlerResult { 19 19 + let devices = get_devices().await.map_err(ErrorInternalServerError)?; 20 20 + Ok(HttpResponse::Ok().json(devices)) 30 21 } 31 22 32 32 - pub async fn connect_bluetooth_device( 33 33 - _ctx: &Context, 34 34 - req: &Request, 35 35 - res: &mut Response, 36 36 - ) -> Result<(), Error> { 37 37 - let address = &req.params[0]; 38 38 - match connect(address).await { 39 39 - Ok(_) => res.set_status(200), 23 23 + pub async fn connect_bluetooth_device(path: web::Path<String>) -> HandlerResult { 24 24 + let address = path.into_inner(); 25 25 + match connect(&address).await { 26 26 + Ok(_) => Ok(HttpResponse::Ok().finish()), 40 27 Err(e) => { 41 28 tracing::error!("bluetooth: connect {}: {}", address, e); 42 42 - res.set_status(500); 29 29 + Ok(HttpResponse::InternalServerError().finish()) 43 30 } 44 31 } 45 45 - Ok(()) 46 32 } 47 33 48 48 - pub async fn disconnect_bluetooth_device( 49 49 - _ctx: &Context, 50 50 - req: &Request, 51 51 - res: &mut Response, 52 52 - ) -> Result<(), Error> { 53 53 - let address = &req.params[0]; 54 54 - match disconnect(address).await { 55 55 - Ok(_) => res.set_status(200), 34 34 + pub async fn disconnect_bluetooth_device(path: web::Path<String>) -> HandlerResult { 35 35 + let address = path.into_inner(); 36 36 + match disconnect(&address).await { 37 37 + Ok(_) => Ok(HttpResponse::Ok().finish()), 56 38 Err(e) => { 57 39 tracing::error!("bluetooth: disconnect {}: {}", address, e); 58 58 - res.set_status(500); 40 40 + Ok(HttpResponse::InternalServerError().finish()) 59 41 } 60 42 } 61 61 - Ok(()) 62 43 }

+44 -41

crates/server/src/handlers/browse.rs

reviewed

··· 1 1 use std::{env, fs}; 2 2 3 3 - use crate::{ 4 4 - cache::update_cache, 5 5 - http::{Context, Request, Response}, 6 6 - AUDIO_EXTENSIONS, 7 7 - }; 8 8 - use anyhow::Error; 3 3 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 9 4 use rockbox_sys::types::tree::Entry; 5 5 + use serde::Deserialize; 6 6 + 7 7 + use crate::{cache::update_cache, http::AppState, AUDIO_EXTENSIONS}; 8 8 + 9 9 + type HandlerResult = actix_web::Result<HttpResponse>; 10 10 + 11 11 + #[derive(Deserialize)] 12 12 + pub struct TreeQuery { 13 13 + q: Option<String>, 14 14 + show_hidden: Option<String>, 15 15 + } 10 16 11 17 pub async fn get_tree_entries( 12 12 - ctx: &Context, 13 13 - req: &Request, 14 14 - res: &mut Response, 15 15 - ) -> Result<(), Error> { 16 16 - let home = env::var("HOME").unwrap(); 17 17 - let music_library = env::var("ROCKBOX_LIBRARY").unwrap_or(format!("{}/Music", home)); 18 18 + state: web::Data<AppState>, 19 19 + query: web::Query<TreeQuery>, 20 20 + ) -> HandlerResult { 21 21 + let home = env::var("HOME").map_err(ErrorInternalServerError)?; 22 22 + let music_library = env::var("ROCKBOX_LIBRARY").unwrap_or_else(|_| format!("{}/Music", home)); 18 23 19 19 - let path = match req.query_params.get("q") { 20 20 - Some(path) => path.as_str().unwrap_or(&music_library), 21 21 - None => &music_library, 22 22 - }; 23 23 - let show_hidden = match req.query_params.get("show_hidden") { 24 24 - Some(show_hidden) => show_hidden.as_str().unwrap_or("false") == "true", 25 25 - None => false, 26 26 - }; 24 24 + let path = query.q.as_deref().unwrap_or(&music_library).to_string(); 25 25 + let show_hidden = query.show_hidden.as_deref() == Some("true"); 27 26 28 28 - if !fs::metadata(path)?.is_dir() { 29 29 - res.set_status(500); 30 30 - res.text("Path is not a directory"); 31 31 - return Ok(()); 27 27 + if !fs::metadata(&path) 28 28 + .map_err(ErrorInternalServerError)? 29 29 + .is_dir() 30 30 + { 31 31 + return Ok(HttpResponse::InternalServerError().body("Path is not a directory")); 32 32 } 33 33 34 34 - let mut fs_cache = ctx.fs_cache.lock().await; 35 35 - if let Some(entries) = fs_cache.get(&path.to_string()) { 36 36 - update_cache(ctx, path, show_hidden); 37 37 - res.json(entries); 38 38 - return Ok(()); 34 34 + let mut fs_cache = state.fs_cache.lock().await; 35 35 + if let Some(entries) = fs_cache.get(&path) { 36 36 + let entries = entries.clone(); 37 37 + drop(fs_cache); 38 38 + update_cache(state.fs_cache.clone(), &path, show_hidden); 39 39 + return Ok(HttpResponse::Ok().json(entries)); 39 40 } 40 41 41 41 - let mut entries = vec![]; 42 42 + let mut entries: Vec<Entry> = vec![]; 42 43 43 43 - for file in fs::read_dir(path)? { 44 44 - let file = file?; 44 44 + for file in fs::read_dir(&path).map_err(ErrorInternalServerError)? { 45 45 + let file = file.map_err(ErrorInternalServerError)?; 45 46 46 46 - if file.metadata()?.is_file() 47 47 + if file.metadata().map_err(ErrorInternalServerError)?.is_file() 47 48 && !AUDIO_EXTENSIONS.iter().any(|ext| { 48 49 file.path() 49 50 .to_string_lossy() ··· 53 54 continue; 54 55 } 55 56 56 56 - if file.file_name().to_string_lossy().starts_with(".") && !show_hidden { 57 57 + if file.file_name().to_string_lossy().starts_with('.') && !show_hidden { 57 58 continue; 58 59 } 59 60 60 61 entries.push(Entry { 61 62 name: file.path().to_string_lossy().to_string(), 62 63 time_write: file 63 63 - .metadata()? 64 64 - .modified()? 65 65 - .duration_since(std::time::SystemTime::UNIX_EPOCH)? 64 64 + .metadata() 65 65 + .map_err(ErrorInternalServerError)? 66 66 + .modified() 67 67 + .map_err(ErrorInternalServerError)? 68 68 + .duration_since(std::time::SystemTime::UNIX_EPOCH) 69 69 + .map_err(ErrorInternalServerError)? 66 70 .as_secs() as u32, 67 67 - attr: match file.metadata()?.is_dir() { 71 71 + attr: match file.metadata().map_err(ErrorInternalServerError)?.is_dir() { 68 72 true => 0x10, 69 73 false => 0, 70 74 }, ··· 72 76 }); 73 77 } 74 78 75 75 - fs_cache.insert(path.to_string(), entries.clone()); 79 79 + fs_cache.insert(path, entries.clone()); 76 80 77 77 - res.json(&entries); 78 78 - Ok(()) 81 81 + Ok(HttpResponse::Ok().json(entries)) 79 82 }

+39 -76

crates/server/src/handlers/devices.rs

reviewed

··· 1 1 - use anyhow::Error; 1 1 + use actix_web::{web, HttpResponse}; 2 2 use rockbox_settings::{read_settings, save_settings_to_file}; 3 3 use rockbox_sys::sound::pcm; 4 4 5 5 - use crate::{ 6 6 - http::{Context, Request, Response}, 7 7 - GLOBAL_MUTEX, 8 8 - }; 5 5 + use crate::{http::AppState, GLOBAL_MUTEX}; 6 6 + 7 7 + type HandlerResult = actix_web::Result<HttpResponse>; 9 8 10 10 - pub async fn connect(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 11 11 - let id = &req.params[0]; 12 12 - let mut player = ctx.player.lock().unwrap(); 13 13 - let mut current_device = ctx.current_device.lock().unwrap(); 14 14 - let mut devices = ctx.devices.lock().unwrap(); 9 9 + pub async fn connect(state: web::Data<AppState>, path: web::Path<String>) -> HandlerResult { 10 10 + let id = path.into_inner(); 11 11 + let mut player = state.player.lock().unwrap(); 12 12 + let mut current_device = state.current_device.lock().unwrap(); 13 13 + let mut devices = state.devices.lock().unwrap(); 15 14 16 16 - let device = match devices.iter().find(|d| d.id == *id).cloned().or_else(|| { 17 17 - // Synthetic device from settings (mDNS not yet found it). 18 18 - current_device.as_ref().filter(|d| d.id == *id).cloned() 19 19 - }) { 15 15 + let device = match devices 16 16 + .iter() 17 17 + .find(|d| d.id == id) 18 18 + .cloned() 19 19 + .or_else(|| current_device.as_ref().filter(|d| d.id == id).cloned()) 20 20 + { 20 21 Some(d) => d, 21 21 - None => { 22 22 - res.set_status(404); 23 23 - return Ok(()); 24 24 - } 22 22 + None => return Ok(HttpResponse::NotFound().finish()), 25 23 }; 26 24 27 27 - // Stop any existing player session. 28 25 if let Some(p) = player.as_mut() { 29 26 let _ = p.stop().await; 30 27 let _ = p.disconnect().await; 31 28 } 32 29 *player = None; 33 30 34 34 - // If switching away from or to Chromecast, tear down the cast session so 35 35 - // the next pcm_chromecast_start() always gets a clean slate. 36 31 let old_service = current_device 37 32 .as_ref() 38 33 .map(|d| d.service.as_str()) ··· 41 36 pcm::chromecast_teardown(); 42 37 } 43 38 44 44 - // Read current settings so we preserve all other fields. 45 39 let mut settings = read_settings().unwrap_or_default(); 46 40 47 41 match device.service.as_str() { ··· 89 83 pcm::upnp_set_renderer_url(url); 90 84 } 91 85 pcm::upnp_set_http_port(http_port); 92 92 - // Reset renderer state so the very next sink_dma_start always fires 93 93 - // SetAVTransportURI + Play — without this, switching back to UPnP after 94 94 - // using another output would leave RENDERER_PLAYING=true and send no 95 95 - // play command, silently producing no audio until daemon restart. 96 86 pcm::upnp_reset_renderer(); 97 87 pcm::switch_sink(pcm::PCM_SINK_UPNP); 98 88 *GLOBAL_MUTEX.lock().unwrap() = 0; ··· 119 109 } 120 110 other => { 121 111 tracing::warn!("connect: unknown device service {:?}", other); 122 122 - res.set_status(400); 123 123 - return Ok(()); 112 112 + return Ok(HttpResponse::BadRequest().finish()); 124 113 } 125 114 } 126 115 127 127 - // Persist and update state before any potentially-failing connection attempt 128 128 - // so that the selection survives even if e.g. the Chromecast is temporarily unreachable. 129 116 if let Err(e) = save_settings_to_file(&settings) { 130 117 tracing::warn!("connect: failed to save settings: {e}"); 131 118 } 132 119 133 133 - // Mark new current device; clear is_current_device on all others. 134 120 for d in devices.iter_mut() { 135 121 d.is_current_device = d.id == device.id; 136 122 } 137 137 - *current_device = Some(device.clone()); 138 138 - 139 139 - // The Cast protocol session is managed entirely by the pcm.rs cast_loop; 140 140 - // no separate lib.rs Chromecast::connect() needed here. 123 123 + *current_device = Some(device); 141 124 142 142 - res.set_status(200); 143 143 - Ok(()) 125 125 + Ok(HttpResponse::Ok().finish()) 144 126 } 145 127 146 146 - pub async fn disconnect(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 147 147 - let _id = &req.params[0]; 148 148 - let mut player = ctx.player.lock().unwrap(); 149 149 - let mut current_device = ctx.current_device.lock().unwrap(); 150 150 - let mut devices = ctx.devices.lock().unwrap(); 128 128 + pub async fn disconnect(state: web::Data<AppState>, _path: web::Path<String>) -> HandlerResult { 129 129 + let mut player = state.player.lock().unwrap(); 130 130 + let mut current_device = state.current_device.lock().unwrap(); 131 131 + let mut devices = state.devices.lock().unwrap(); 151 132 152 133 if let Some(p) = player.as_mut() { 153 134 let _ = p.stop().await; ··· 156 137 *GLOBAL_MUTEX.lock().unwrap() = 0; 157 138 *player = None; 158 139 159 159 - // If disconnecting from Chromecast, stop the cast loop before switching sink. 160 140 if current_device 161 141 .as_ref() 162 142 .map_or(false, |d| d.service == "chromecast") ··· 164 144 pcm::chromecast_teardown(); 165 145 } 166 146 167 167 - // Fall back to built-in sink. 168 147 pcm::switch_sink(pcm::PCM_SINK_BUILTIN); 169 148 170 149 let mut settings = read_settings().unwrap_or_default(); ··· 173 152 tracing::warn!("disconnect: failed to save settings: {e}"); 174 153 } 175 154 176 176 - // Mark built-in as current. 177 155 for d in devices.iter_mut() { 178 156 d.is_current_device = d.id == "builtin"; 179 157 } 180 158 *current_device = devices.iter().find(|d| d.id == "builtin").cloned(); 181 159 182 182 - res.set_status(200); 183 183 - Ok(()) 160 160 + Ok(HttpResponse::Ok().finish()) 184 161 } 185 162 186 186 - pub async fn get_devices(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 187 187 - let current = ctx.current_device.lock().unwrap().clone(); 188 188 - let devices = ctx.devices.lock().unwrap(); 163 163 + pub async fn get_devices(state: web::Data<AppState>) -> HandlerResult { 164 164 + let current = state.current_device.lock().unwrap().clone(); 165 165 + let devices = state.devices.lock().unwrap(); 189 166 190 167 let mut result: Vec<_> = devices 191 168 .iter() ··· 199 176 }) 200 177 .collect(); 201 178 202 202 - // If the current device isn't in the discovered list yet (e.g. Chromecast 203 203 - // from settings but mDNS hasn't found it), include it so UIs can show it. 204 179 if let Some(ref cd) = current { 205 180 if !result.iter().any(|d| devices_match(cd, d)) { 206 181 result.push(cd.clone()); 207 182 } 208 183 } 209 184 210 210 - res.json(&result); 211 211 - Ok(()) 185 185 + Ok(HttpResponse::Ok().json(result)) 212 186 } 213 187 214 214 - /// Two devices represent the same physical output if their IDs match OR if 215 215 - /// their service + IP match (handles ID format differences between settings- 216 216 - /// based synthetic devices and mDNS-discovered ones). 217 188 fn devices_match(a: &rockbox_types::device::Device, b: &rockbox_types::device::Device) -> bool { 218 189 if a.id == b.id { 219 190 return true; ··· 227 198 } 228 199 } 229 200 230 230 - pub async fn get_device(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 231 231 - let id = &req.params[0]; 201 201 + pub async fn get_device(state: web::Data<AppState>, path: web::Path<String>) -> HandlerResult { 202 202 + let id = path.into_inner(); 232 203 if id == "current" { 233 233 - let current_device = ctx.current_device.lock().unwrap(); 234 234 - if let Some(device) = current_device.as_ref() { 235 235 - res.json(&device.clone()); 236 236 - return Ok(()); 237 237 - } 238 238 - res.set_status(404); 239 239 - return Ok(()); 204 204 + let current_device = state.current_device.lock().unwrap(); 205 205 + return match current_device.as_ref() { 206 206 + Some(device) => Ok(HttpResponse::Ok().json(device)), 207 207 + None => Ok(HttpResponse::NotFound().finish()), 208 208 + }; 240 209 } 241 210 242 242 - let devices = ctx.devices.lock().unwrap(); 243 243 - let device = devices.iter().find(|d| d.id == *id); 244 244 - 245 245 - if let Some(device) = device { 246 246 - res.json(&device.clone()); 247 247 - return Ok(()); 211 211 + let devices = state.devices.lock().unwrap(); 212 212 + match devices.iter().find(|d| d.id == id) { 213 213 + Some(device) => Ok(HttpResponse::Ok().json(device)), 214 214 + None => Ok(HttpResponse::NotFound().finish()), 248 215 } 249 249 - 250 250 - res.json(&device); 251 251 - res.set_status(404); 252 252 - Ok(()) 253 216 }

+9 -11

crates/server/src/handlers/docs.rs

reviewed

··· 1 1 - use anyhow::Error; 1 1 + use actix_web::HttpResponse; 2 2 3 3 - use crate::http::{Context, Request, Response}; 3 3 + type HandlerResult = actix_web::Result<HttpResponse>; 4 4 5 5 - pub async fn get_openapi(_ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 5 5 + pub async fn get_openapi() -> HandlerResult { 6 6 let spec = include_str!("../../openapi.json"); 7 7 - res.add_header("Content-Type", "application/json"); 8 8 - res.set_body(spec); 9 9 - Ok(()) 7 7 + Ok(HttpResponse::Ok() 8 8 + .content_type("application/json") 9 9 + .body(spec)) 10 10 } 11 11 12 12 - pub async fn index(_ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 13 13 - let index = include_str!("../../docs/index.html"); 14 14 - res.add_header("Content-Type", "text/html"); 15 15 - res.set_body(index); 16 16 - Ok(()) 12 12 + pub async fn index() -> HandlerResult { 13 13 + let html = include_str!("../../docs/index.html"); 14 14 + Ok(HttpResponse::Ok().content_type("text/html").body(html)) 17 15 }

-100

crates/server/src/handlers/mod.rs

reviewed

··· 13 13 pub mod smart_playlists; 14 14 pub mod system; 15 15 pub mod tracks; 16 16 - 17 17 - use crate::http::{Context, Request, Response}; 18 18 - use anyhow::Error; 19 19 - 20 20 - macro_rules! async_handler { 21 21 - ($module:ident, $handler:ident) => { 22 22 - pub fn $handler( 23 23 - context: &Context, 24 24 - request: &Request, 25 25 - response: &mut Response, 26 26 - ) -> Result<(), Error> { 27 27 - context 28 28 - .rt 29 29 - .block_on($module::$handler(context, request, response))?; 30 30 - Ok(()) 31 31 - } 32 32 - }; 33 33 - } 34 34 - 35 35 - async_handler!(albums, get_albums); 36 36 - async_handler!(albums, get_album); 37 37 - async_handler!(albums, get_album_tracks); 38 38 - async_handler!(artists, get_artists); 39 39 - async_handler!(artists, get_artist); 40 40 - async_handler!(artists, get_artist_albums); 41 41 - async_handler!(artists, get_artist_tracks); 42 42 - async_handler!(browse, get_tree_entries); 43 43 - async_handler!(player, load); 44 44 - async_handler!(player, play); 45 45 - async_handler!(player, pause); 46 46 - async_handler!(player, resume); 47 47 - async_handler!(player, ff_rewind); 48 48 - async_handler!(player, status); 49 49 - async_handler!(player, current_track); 50 50 - async_handler!(player, next_track); 51 51 - async_handler!(player, flush_and_reload_tracks); 52 52 - async_handler!(player, next); 53 53 - async_handler!(player, previous); 54 54 - async_handler!(player, stop); 55 55 - async_handler!(player, get_file_position); 56 56 - async_handler!(player, get_volume); 57 57 - async_handler!(player, adjust_volume); 58 58 - async_handler!(player, get_current_player); 59 59 - async_handler!(playlists, create_playlist); 60 60 - async_handler!(playlists, start_playlist); 61 61 - async_handler!(playlists, shuffle_playlist); 62 62 - async_handler!(playlists, get_playlist_amount); 63 63 - async_handler!(playlists, resume_playlist); 64 64 - async_handler!(playlists, resume_track); 65 65 - async_handler!(playlists, get_playlist_tracks); 66 66 - async_handler!(playlists, insert_tracks); 67 67 - async_handler!(playlists, remove_tracks); 68 68 - async_handler!(playlists, get_playlist); 69 69 - async_handler!(saved_playlists, list_saved_playlists); 70 70 - async_handler!(saved_playlists, get_saved_playlist); 71 71 - async_handler!(saved_playlists, create_saved_playlist); 72 72 - async_handler!(saved_playlists, update_saved_playlist); 73 73 - async_handler!(saved_playlists, delete_saved_playlist); 74 74 - async_handler!(saved_playlists, get_saved_playlist_tracks); 75 75 - async_handler!(saved_playlists, get_saved_playlist_track_ids); 76 76 - async_handler!(saved_playlists, add_tracks_to_saved_playlist); 77 77 - async_handler!(saved_playlists, remove_track_from_saved_playlist); 78 78 - async_handler!(saved_playlists, play_saved_playlist); 79 79 - async_handler!(saved_playlists, list_playlist_folders); 80 80 - async_handler!(saved_playlists, create_playlist_folder); 81 81 - async_handler!(saved_playlists, delete_playlist_folder); 82 82 - async_handler!(tracks, get_tracks); 83 83 - async_handler!(tracks, get_track); 84 84 - async_handler!(tracks, save_stream_track_metadata); 85 85 - async_handler!(system, get_rockbox_version); 86 86 - async_handler!(system, get_status); 87 87 - async_handler!(system, scan_library); 88 88 - async_handler!(settings, get_global_settings); 89 89 - async_handler!(settings, update_global_settings); 90 90 - async_handler!(docs, get_openapi); 91 91 - async_handler!(docs, index); 92 92 - async_handler!(search, search); 93 93 - async_handler!(devices, connect); 94 94 - async_handler!(devices, disconnect); 95 95 - async_handler!(devices, get_devices); 96 96 - async_handler!(devices, get_device); 97 97 - async_handler!(smart_playlists, list_smart_playlists); 98 98 - async_handler!(smart_playlists, get_smart_playlist); 99 99 - async_handler!(smart_playlists, create_smart_playlist); 100 100 - async_handler!(smart_playlists, update_smart_playlist); 101 101 - async_handler!(smart_playlists, delete_smart_playlist); 102 102 - async_handler!(smart_playlists, get_smart_playlist_tracks); 103 103 - async_handler!(smart_playlists, play_smart_playlist); 104 104 - async_handler!(smart_playlists, record_track_played); 105 105 - async_handler!(smart_playlists, record_track_skipped); 106 106 - async_handler!(smart_playlists, get_track_stats); 107 107 - 108 108 - #[cfg(target_os = "linux")] 109 109 - async_handler!(bluetooth, scan_bluetooth); 110 110 - #[cfg(target_os = "linux")] 111 111 - async_handler!(bluetooth, get_bluetooth_devices); 112 112 - #[cfg(target_os = "linux")] 113 113 - async_handler!(bluetooth, connect_bluetooth_device); 114 114 - #[cfg(target_os = "linux")] 115 115 - async_handler!(bluetooth, disconnect_bluetooth_device);

+324 -304

crates/server/src/handlers/player.rs

reviewed

··· 1 1 use std::{env, ffi::CString}; 2 2 3 3 - use crate::PLAYER_MUTEX; 4 4 - use crate::{ 5 5 - http::{Context, Request, Response}, 6 6 - GLOBAL_MUTEX, 7 7 - }; 8 8 - use anyhow::{anyhow, Error}; 3 3 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 9 4 use local_ip_addr::get_local_ip_address; 10 5 use rand::seq::SliceRandom; 11 6 use rockbox_chromecast::Chromecast; ··· 16 11 }; 17 12 use rockbox_traits::types::track::Track; 18 13 use rockbox_types::{device::Device, LoadTracks, NewVolume}; 14 14 + use serde::Deserialize; 15 15 + 16 16 + use crate::{http::AppState, GLOBAL_MUTEX, PLAYER_MUTEX}; 17 17 + 18 18 + type HandlerResult = actix_web::Result<HttpResponse>; 19 19 20 20 unsafe extern "C" { 21 21 fn save_remote_track_metadata(url: *const std::ffi::c_char) -> i32; 22 22 } 23 23 24 24 - pub async fn load(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 25 25 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 26 26 - let mut player = ctx.player.lock().unwrap(); 24 24 + pub async fn load(state: web::Data<AppState>, body: web::Json<LoadTracks>) -> HandlerResult { 25 25 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 26 26 + let mut player = state.player.lock().unwrap(); 27 27 if player.is_none() { 28 28 - res.set_status(404); 29 29 - return Ok(()); 28 28 + return Ok(HttpResponse::NotFound().finish()); 30 29 } 31 30 32 32 - let mut current_device = ctx.current_device.lock().unwrap(); 33 33 - let devices = ctx.devices.lock().unwrap(); 31 31 + let mut current_device = state.current_device.lock().unwrap(); 32 32 + let devices = state.devices.lock().unwrap(); 34 33 let device = devices 35 34 .iter() 36 36 - .find(|d| d.id == *current_device.as_ref().unwrap().id); 35 35 + .find(|d| d.id == *current_device.as_ref().unwrap().id) 36 36 + .cloned(); 37 37 if let Some(device) = device { 38 38 let mut mutex = GLOBAL_MUTEX.lock().unwrap(); 39 39 *mutex = 1; 40 40 - *player = Chromecast::connect(device.clone())?; 41 41 - *current_device = Some(device.clone()); 40 40 + *player = Chromecast::connect(device.clone()).map_err(ErrorInternalServerError)?; 41 41 + *current_device = Some(device); 42 42 } 43 43 44 44 let player = player.as_deref_mut().unwrap(); 45 45 46 46 - let req_body = req.body.as_ref().unwrap(); 47 47 - let request: LoadTracks = serde_json::from_str(&req_body)?; 46 46 + let request = body.into_inner(); 48 47 49 48 for path in &request.tracks { 50 49 if path.starts_with("http://") || path.starts_with("https://") { 51 51 - ensure_remote_track_metadata(path.clone()).await?; 50 50 + ensure_remote_track_metadata(path.clone()) 51 51 + .await 52 52 + .map_err(ErrorInternalServerError)?; 52 53 } 53 54 } 54 55 ··· 58 59 59 60 for requested_path in &request.tracks { 60 61 let track = { 61 61 - let kv = ctx.kv.lock().unwrap(); 62 62 + let kv = state.kv.lock().unwrap(); 62 63 kv.get(requested_path).cloned() 63 64 }; 64 65 65 66 let track = match track { 66 66 - Some(track) => Some(track), 67 67 + Some(t) => Some(t), 67 68 None => { 68 68 - let track = repo::track::find_by_path(ctx.pool.clone(), requested_path).await?; 69 69 - if let Some(ref track) = track { 70 70 - let mut kv = ctx.kv.lock().unwrap(); 71 71 - kv.set(requested_path, track.clone()); 69 69 + let t = repo::track::find_by_path(state.pool.clone(), requested_path) 70 70 + .await 71 71 + .map_err(ErrorInternalServerError)?; 72 72 + if let Some(ref t) = t { 73 73 + let mut kv = state.kv.lock().unwrap(); 74 74 + kv.set(requested_path, t.clone()); 72 75 } 73 73 - track 76 76 + t 74 77 } 75 78 }; 76 79 ··· 100 103 } 101 104 102 105 if tracks.is_empty() { 103 103 - res.set_status(404); 104 104 - res.text("No playable tracks found"); 105 105 - return Ok(()); 106 106 + return Ok(HttpResponse::NotFound().body("No playable tracks found")); 106 107 } 107 108 109 109 + let mut tracks = tracks; 108 110 if Some(true) == request.shuffle { 109 111 tracks.shuffle(&mut rand::thread_rng()); 110 112 } 111 113 112 112 - player.load_tracks(tracks, None).await?; 114 114 + player 115 115 + .load_tracks(tracks, None) 116 116 + .await 117 117 + .map_err(ErrorInternalServerError)?; 113 118 114 114 - res.set_status(200); 119 119 + Ok(HttpResponse::Ok().finish()) 120 120 + } 115 121 116 116 - drop(player_mutex); 117 117 - 118 118 - Ok(()) 122 122 + #[derive(Deserialize)] 123 123 + pub struct PlayQuery { 124 124 + pub elapsed: Option<i64>, 125 125 + pub offset: Option<i64>, 119 126 } 120 127 121 121 - pub async fn play(ctx: &Context, req: &Request, _res: &mut Response) -> Result<(), Error> { 122 122 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 123 123 - let elapsed = match req.query_params.get("elapsed") { 124 124 - Some(elapsed) => elapsed.as_str().unwrap_or("0").parse().unwrap_or(0), 125 125 - None => 0, 126 126 - }; 127 127 - let offset = match req.query_params.get("offset") { 128 128 - Some(offset) => offset.as_str().unwrap_or("0").parse().unwrap_or(0), 129 129 - None => 0, 130 130 - }; 131 131 - let player = ctx.player.lock().unwrap(); 128 128 + pub async fn play(state: web::Data<AppState>, query: web::Query<PlayQuery>) -> HandlerResult { 129 129 + let elapsed = query.elapsed.unwrap_or(0); 130 130 + let offset = query.offset.unwrap_or(0); 132 131 133 133 - if player.is_none() { 134 134 - rb::playback::play(elapsed, offset); 135 135 - } 132 132 + web::block(move || { 133 133 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 134 134 + if state.player.lock().unwrap().is_none() { 135 135 + rb::playback::play(elapsed, offset); 136 136 + } 137 137 + }) 138 138 + .await 139 139 + .map_err(ErrorInternalServerError)?; 136 140 137 137 - drop(player_mutex); 138 138 - 139 139 - Ok(()) 141 141 + Ok(HttpResponse::Ok().finish()) 140 142 } 141 143 142 142 - pub async fn pause(ctx: &Context, _req: &Request, _res: &mut Response) -> Result<(), Error> { 143 143 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 144 144 - let player = ctx.player.lock().unwrap(); 144 144 + pub async fn pause(state: web::Data<AppState>) -> HandlerResult { 145 145 + let has_external = state.player.lock().unwrap().is_some(); 145 146 146 146 - match player.as_deref() { 147 147 - Some(player) => { 148 148 - player.pause().await?; 147 147 + if has_external { 148 148 + let mut player = state.player.lock().unwrap(); 149 149 + if let Some(p) = player.as_deref_mut() { 150 150 + p.pause().await.map_err(ErrorInternalServerError)?; 149 151 } 150 150 - None => { 152 152 + } else { 153 153 + web::block(move || { 154 154 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 151 155 rb::playback::pause(); 152 152 - } 156 156 + }) 157 157 + .await 158 158 + .map_err(ErrorInternalServerError)?; 153 159 } 154 160 155 155 - drop(player_mutex); 161 161 + Ok(HttpResponse::Ok().finish()) 162 162 + } 156 163 157 157 - Ok(()) 164 164 + #[derive(Deserialize)] 165 165 + pub struct FfRewindQuery { 166 166 + pub newtime: Option<i32>, 158 167 } 159 168 160 160 - pub async fn ff_rewind(_ctx: &Context, req: &Request, _res: &mut Response) -> Result<(), Error> { 161 161 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 162 162 - let newtime = match req.query_params.get("newtime") { 163 163 - Some(newtime) => newtime.as_str().unwrap_or("0").parse().unwrap_or(0), 164 164 - None => 0, 165 165 - }; 166 166 - rb::playback::ff_rewind(newtime); 167 167 - 168 168 - drop(player_mutex); 169 169 - 170 170 - Ok(()) 169 169 + pub async fn ff_rewind(query: web::Query<FfRewindQuery>) -> HandlerResult { 170 170 + let newtime = query.newtime.unwrap_or(0); 171 171 + web::block(move || { 172 172 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 173 173 + rb::playback::ff_rewind(newtime); 174 174 + }) 175 175 + .await 176 176 + .map_err(ErrorInternalServerError)?; 177 177 + Ok(HttpResponse::Ok().finish()) 171 178 } 172 179 173 173 - pub async fn status(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 174 174 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 175 175 - let mut player = ctx.player.lock().unwrap(); 180 180 + pub async fn status(state: web::Data<AppState>) -> HandlerResult { 181 181 + let has_external = state.player.lock().unwrap().is_some(); 176 182 177 177 - if let Some(player) = player.as_deref_mut() { 178 178 - let current_playback = player.get_current_playback().await?; 179 179 - res.json(&AudioStatus { 180 180 - status: match current_playback.is_playing { 181 181 - true => 1, 182 182 - false => 0, 183 183 - }, 184 184 - }); 185 185 - return Ok(()); 183 183 + if has_external { 184 184 + let mut player = state.player.lock().unwrap(); 185 185 + if let Some(p) = player.as_deref_mut() { 186 186 + let current_playback = p 187 187 + .get_current_playback() 188 188 + .await 189 189 + .map_err(ErrorInternalServerError)?; 190 190 + return Ok(HttpResponse::Ok().json(AudioStatus { 191 191 + status: if current_playback.is_playing { 1 } else { 0 }, 192 192 + })); 193 193 + } 186 194 } 187 195 188 188 - let status = rb::playback::status(); 189 189 - res.json(&status); 196 196 + let status = web::block(|| { 197 197 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 198 198 + rb::playback::status() 199 199 + }) 200 200 + .await 201 201 + .map_err(ErrorInternalServerError)?; 202 202 + 203 203 + Ok(HttpResponse::Ok().json(status)) 204 204 + } 190 205 191 191 - drop(player_mutex); 206 206 + pub async fn current_track(state: web::Data<AppState>) -> HandlerResult { 207 207 + let has_external = state.player.lock().unwrap().is_some(); 208 208 + 209 209 + if has_external { 210 210 + let mut player = state.player.lock().unwrap(); 211 211 + if let Some(p) = player.as_deref_mut() { 212 212 + let current_playback = p 213 213 + .get_current_playback() 214 214 + .await 215 215 + .map_err(ErrorInternalServerError)?; 216 216 + let mut track: Option<Mp3Entry> = current_playback.current_track.map(|mut t| { 217 217 + if t.path.is_empty() { 218 218 + t.path = t.uri.clone(); 219 219 + } 220 220 + t.into() 221 221 + }); 192 222 193 193 - Ok(()) 194 194 - } 223 223 + if let Some(lookup_path) = track 224 224 + .as_ref() 225 225 + .map(|t| t.path.clone()) 226 226 + .filter(|path| !path.is_empty()) 227 227 + { 228 228 + let metadata = find_track_metadata(&state, &lookup_path) 229 229 + .await 230 230 + .map_err(ErrorInternalServerError)?; 231 231 + if let Some(metadata) = metadata { 232 232 + let t = track.as_mut().unwrap(); 233 233 + t.id = Some(metadata.id); 234 234 + t.album_art = metadata.album_art.or(t.album_art.clone()); 235 235 + t.album_id = Some(metadata.album_id); 236 236 + t.artist_id = Some(metadata.artist_id); 237 237 + } 238 238 + } 195 239 196 196 - pub async fn current_track(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 197 197 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 198 198 - let mut player = ctx.player.lock().unwrap(); 240 240 + let track = track.map(|mut t| { 241 241 + t.elapsed = current_playback.position_ms as u64; 242 242 + t 243 243 + }); 244 244 + return Ok(HttpResponse::Ok().json(track)); 245 245 + } 246 246 + } 199 247 200 200 - if let Some(player) = player.as_deref_mut() { 201 201 - let current_playback = player.get_current_playback().await?; 202 202 - let mut track: Option<Mp3Entry> = current_playback.current_track.map(|mut t| { 203 203 - if t.path.is_empty() { 204 204 - t.path = t.uri.clone(); 248 248 + // Builtin player: FFI calls on a blocking thread, then DB lookup async 249 249 + let (track, audio_path, playlist_path) = web::block(|| { 250 250 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 251 251 + let track = rb::playback::current_track(); 252 252 + let audio_path: Option<String> = track.as_ref().map(|t| t.path.clone()); 253 253 + let playlist_index = rb::playlist::index(); 254 254 + let playlist_path = if playlist_index >= 0 { 255 255 + let info = rb::playlist::get_track_info(playlist_index); 256 256 + if !info.filename.is_empty() { 257 257 + Some(info.filename) 258 258 + } else { 259 259 + None 205 260 } 206 206 - t.into() 207 207 - }); 261 261 + } else { 262 262 + None 263 263 + }; 264 264 + (track, audio_path, playlist_path) 265 265 + }) 266 266 + .await 267 267 + .map_err(ErrorInternalServerError)?; 208 268 209 209 - if let Some(lookup_path) = track 210 210 - .as_ref() 211 211 - .map(|t| t.path.clone()) 212 212 - .filter(|path| !path.is_empty()) 269 269 + let mut track = track; 270 270 + let lookup_path = playlist_path.or(audio_path); 271 271 + if let Some(path) = lookup_path { 272 272 + if let Some(metadata) = find_track_metadata(&state, &path) 273 273 + .await 274 274 + .map_err(ErrorInternalServerError)? 213 275 { 214 214 - let metadata = find_track_metadata(ctx, &lookup_path).await?; 215 215 - if let Some(metadata) = metadata { 216 216 - let current_track = track.as_mut().unwrap(); 217 217 - current_track.id = Some(metadata.id); 218 218 - current_track.album_art = metadata.album_art.or(current_track.album_art.clone()); 219 219 - current_track.album_id = Some(metadata.album_id); 220 220 - current_track.artist_id = Some(metadata.artist_id); 276 276 + if let Some(t) = track.as_mut() { 277 277 + t.id = Some(metadata.id); 278 278 + t.album_art = metadata.album_art; 279 279 + t.album_id = Some(metadata.album_id); 280 280 + t.artist_id = Some(metadata.artist_id); 221 281 } 222 282 } 283 283 + } 284 284 + Ok(HttpResponse::Ok().json(track)) 285 285 + } 223 286 224 224 - let track = track.map(|mut t| { 225 225 - t.elapsed = current_playback.position_ms as u64; 226 226 - t 227 227 - }); 228 228 - res.json(&track); 229 229 - return Ok(()); 287 287 + pub async fn next_track(state: web::Data<AppState>) -> HandlerResult { 288 288 + if state.player.lock().unwrap().is_some() { 289 289 + return Ok(HttpResponse::Ok().json(Option::<Mp3Entry>::None)); 230 290 } 231 291 232 232 - let mut track = rb::playback::current_track(); 233 233 - let audio_path: Option<String> = track.as_ref().map(|t| t.path.clone()); 234 234 - 235 235 - // Use the playlist filename for DB lookup — it matches the key under which 236 236 - // metadata was saved (e.g. the HTTP URL) and is what the broker uses to 237 237 - // display album art correctly. audio_current_track()->path can diverge for 238 238 - // HTTP stream tracks so we treat it only as a fallback. 239 239 - let playlist_index = rb::playlist::index(); 240 240 - let playlist_path = if playlist_index >= 0 { 241 241 - let info = rb::playlist::get_track_info(playlist_index); 242 242 - if !info.filename.is_empty() { 243 243 - Some(info.filename) 292 292 + let (track, audio_path, playlist_path) = web::block(|| { 293 293 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 294 294 + let track = rb::playback::next_track(); 295 295 + let audio_path: Option<String> = track.as_ref().map(|t| t.path.clone()); 296 296 + let current_index = rb::playlist::index(); 297 297 + let next_index = current_index + 1; 298 298 + let playlist_path = if next_index >= 0 && next_index < rb::playlist::amount() { 299 299 + let info = rb::playlist::get_track_info(next_index); 300 300 + if !info.filename.is_empty() { 301 301 + Some(info.filename) 302 302 + } else { 303 303 + None 304 304 + } 244 305 } else { 245 306 None 246 246 - } 247 247 - } else { 248 248 - None 249 249 - }; 307 307 + }; 308 308 + (track, audio_path, playlist_path) 309 309 + }) 310 310 + .await 311 311 + .map_err(ErrorInternalServerError)?; 250 312 313 313 + let mut track = track; 251 314 let lookup_path = playlist_path.or(audio_path); 252 315 if let Some(path) = lookup_path { 253 253 - if let Some(metadata) = find_track_metadata(ctx, &path).await? { 254 254 - track.as_mut().unwrap().id = Some(metadata.id); 255 255 - track.as_mut().unwrap().album_art = metadata.album_art; 256 256 - track.as_mut().unwrap().album_id = Some(metadata.album_id); 257 257 - track.as_mut().unwrap().artist_id = Some(metadata.artist_id); 316 316 + let hash = format!("{:x}", md5::compute(path.as_bytes())); 317 317 + if let Some(metadata) = repo::track::find_by_md5(state.pool.clone(), &hash) 318 318 + .await 319 319 + .map_err(ErrorInternalServerError)? 320 320 + { 321 321 + if let Some(t) = track.as_mut() { 322 322 + t.id = Some(metadata.id); 323 323 + t.album_art = metadata.album_art; 324 324 + t.album_id = Some(metadata.album_id); 325 325 + t.artist_id = Some(metadata.artist_id); 326 326 + } 327 327 + } 328 328 + } 329 329 + Ok(HttpResponse::Ok().json(track)) 330 330 + } 331 331 + 332 332 + pub async fn flush_and_reload_tracks() -> HandlerResult { 333 333 + web::block(|| { 334 334 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 335 335 + rb::playback::flush_and_reload_tracks(); 336 336 + }) 337 337 + .await 338 338 + .map_err(ErrorInternalServerError)?; 339 339 + Ok(HttpResponse::Ok().finish()) 340 340 + } 341 341 + 342 342 + pub async fn resume(state: web::Data<AppState>) -> HandlerResult { 343 343 + let has_external = state.player.lock().unwrap().is_some(); 344 344 + 345 345 + if has_external { 346 346 + let mut player = state.player.lock().unwrap(); 347 347 + if let Some(p) = player.as_deref_mut() { 348 348 + p.play().await.map_err(ErrorInternalServerError)?; 258 349 } 350 350 + } else { 351 351 + web::block(|| { 352 352 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 353 353 + rb::playback::resume(); 354 354 + }) 355 355 + .await 356 356 + .map_err(ErrorInternalServerError)?; 259 357 } 260 260 - res.json(&track); 358 358 + 359 359 + Ok(HttpResponse::Ok().finish()) 360 360 + } 361 361 + 362 362 + pub async fn next() -> HandlerResult { 363 363 + web::block(|| { 364 364 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 365 365 + rb::playback::next(); 366 366 + }) 367 367 + .await 368 368 + .map_err(ErrorInternalServerError)?; 369 369 + Ok(HttpResponse::Ok().finish()) 370 370 + } 371 371 + 372 372 + pub async fn previous() -> HandlerResult { 373 373 + web::block(|| { 374 374 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 375 375 + rb::playback::prev(); 376 376 + }) 377 377 + .await 378 378 + .map_err(ErrorInternalServerError)?; 379 379 + Ok(HttpResponse::Ok().finish()) 380 380 + } 261 381 262 262 - drop(player_mutex); 382 382 + pub async fn stop() -> HandlerResult { 383 383 + web::block(|| { 384 384 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 385 385 + rb::playback::hard_stop(); 386 386 + }) 387 387 + .await 388 388 + .map_err(ErrorInternalServerError)?; 389 389 + Ok(HttpResponse::Ok().finish()) 390 390 + } 391 391 + 392 392 + pub async fn get_file_position() -> HandlerResult { 393 393 + let position = web::block(|| { 394 394 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 395 395 + rb::playback::get_file_pos() 396 396 + }) 397 397 + .await 398 398 + .map_err(ErrorInternalServerError)?; 399 399 + Ok(HttpResponse::Ok().json(position)) 400 400 + } 263 401 264 264 - Ok(()) 402 402 + pub async fn get_volume() -> HandlerResult { 403 403 + let (volume, min, max) = web::block(|| { 404 404 + const SOUND_VOLUME: i32 = 0; 405 405 + ( 406 406 + rb::sound::current(SOUND_VOLUME), 407 407 + rb::sound::min(SOUND_VOLUME), 408 408 + rb::sound::max(SOUND_VOLUME), 409 409 + ) 410 410 + }) 411 411 + .await 412 412 + .map_err(ErrorInternalServerError)?; 413 413 + Ok(HttpResponse::Ok().json(serde_json::json!({ "volume": volume, "min": min, "max": max }))) 414 414 + } 415 415 + 416 416 + pub async fn adjust_volume(body: web::Json<NewVolume>) -> HandlerResult { 417 417 + let new_volume = body.into_inner(); 418 418 + let steps = new_volume.steps; 419 419 + web::block(move || rb::sound::adjust_volume(steps)) 420 420 + .await 421 421 + .map_err(ErrorInternalServerError)?; 422 422 + Ok(HttpResponse::Ok().json(new_volume)) 423 423 + } 424 424 + 425 425 + pub async fn get_current_player(state: web::Data<AppState>) -> HandlerResult { 426 426 + let device = state.current_device.lock().unwrap(); 427 427 + 428 428 + if let Some(device) = device.as_ref() { 429 429 + return Ok(HttpResponse::Ok().json(device)); 430 430 + } 431 431 + 432 432 + Ok(HttpResponse::Ok().json(Device { 433 433 + name: "Rockbox (Default Player)".to_string(), 434 434 + app: "default".to_string(), 435 435 + service: "rockbox".to_string(), 436 436 + ..Default::default() 437 437 + })) 265 438 } 266 439 267 440 async fn find_track_metadata( 268 268 - ctx: &Context, 441 441 + state: &AppState, 269 442 path: &str, 270 270 - ) -> Result<Option<rockbox_library::entity::track::Track>, Error> { 443 443 + ) -> Result<Option<rockbox_library::entity::track::Track>, anyhow::Error> { 271 444 let hash = format!("{:x}", md5::compute(path.as_bytes())); 272 272 - let mut metadata = repo::track::find_by_md5(ctx.pool.clone(), &hash).await?; 273 273 - let internal_track = find_internal_track_by_url(ctx, path).await?; 445 445 + let mut metadata = repo::track::find_by_md5(state.pool.clone(), &hash).await?; 446 446 + let internal_track = find_internal_track_by_url(state, path).await?; 274 447 275 448 if metadata 276 449 .as_ref() ··· 290 463 && internal_track.is_none() 291 464 { 292 465 ensure_remote_track_metadata(path.to_string()).await?; 293 293 - metadata = repo::track::find_by_md5(ctx.pool.clone(), &hash).await?; 466 466 + metadata = repo::track::find_by_md5(state.pool.clone(), &hash).await?; 294 467 } 295 468 } 296 469 297 470 Ok(metadata) 298 471 } 299 472 300 300 - async fn ensure_remote_track_metadata(path: String) -> Result<(), Error> { 301 301 - let status = tokio::task::spawn_blocking(move || -> Result<i32, Error> { 473 473 + async fn ensure_remote_track_metadata(path: String) -> Result<(), anyhow::Error> { 474 474 + let status = tokio::task::spawn_blocking(move || -> Result<i32, anyhow::Error> { 302 475 let path_cstr = CString::new(path.as_str())?; 303 476 Ok(unsafe { save_remote_track_metadata(path_cstr.as_ptr()) }) 304 477 }) 305 478 .await??; 306 479 307 480 if status != 0 { 308 308 - return Err(anyhow!("failed to save remote metadata")); 481 481 + return Err(anyhow::anyhow!("failed to save remote metadata")); 309 482 } 310 483 311 484 Ok(()) 312 485 } 313 486 314 487 async fn find_internal_track_by_url( 315 315 - ctx: &Context, 488 488 + state: &AppState, 316 489 path: &str, 317 317 - ) -> Result<Option<rockbox_library::entity::track::Track>, Error> { 490 490 + ) -> Result<Option<rockbox_library::entity::track::Track>, anyhow::Error> { 318 491 let url = match reqwest::Url::parse(path) { 319 492 Ok(url) => url, 320 493 Err(_) => return Ok(None), ··· 336 509 return Ok(None); 337 510 } 338 511 339 339 - repo::track::find(ctx.pool.clone(), track_id) 512 512 + repo::track::find(state.pool.clone(), track_id) 340 513 .await 341 514 .map_err(Into::into) 342 515 } 343 343 - 344 344 - pub async fn next_track(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 345 345 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 346 346 - let player = ctx.player.lock().unwrap(); 347 347 - 348 348 - if let Some(_player) = player.as_deref() { 349 349 - return Ok(()); 350 350 - } 351 351 - 352 352 - let mut track = rb::playback::next_track(); 353 353 - let audio_path: Option<String> = track.as_ref().map(|t| t.path.clone()); 354 354 - 355 355 - // Use the next playlist entry's filename for DB lookup for the same reason 356 356 - // as in current_track: playlist filename matches the saved metadata key. 357 357 - let current_index = rb::playlist::index(); 358 358 - let next_index = current_index + 1; 359 359 - let playlist_path = if next_index >= 0 && next_index < rb::playlist::amount() { 360 360 - let info = rb::playlist::get_track_info(next_index); 361 361 - if !info.filename.is_empty() { 362 362 - Some(info.filename) 363 363 - } else { 364 364 - None 365 365 - } 366 366 - } else { 367 367 - None 368 368 - }; 369 369 - 370 370 - let lookup_path = playlist_path.or(audio_path); 371 371 - if let Some(path) = lookup_path { 372 372 - let hash = format!("{:x}", md5::compute(path.as_bytes())); 373 373 - if let Some(metadata) = repo::track::find_by_md5(ctx.pool.clone(), &hash).await? { 374 374 - track.as_mut().unwrap().id = Some(metadata.id); 375 375 - track.as_mut().unwrap().album_art = metadata.album_art; 376 376 - track.as_mut().unwrap().album_id = Some(metadata.album_id); 377 377 - track.as_mut().unwrap().artist_id = Some(metadata.artist_id); 378 378 - } 379 379 - } 380 380 - res.json(&track); 381 381 - 382 382 - drop(player_mutex); 383 383 - 384 384 - Ok(()) 385 385 - } 386 386 - 387 387 - pub async fn flush_and_reload_tracks( 388 388 - _ctx: &Context, 389 389 - _req: &Request, 390 390 - _res: &mut Response, 391 391 - ) -> Result<(), Error> { 392 392 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 393 393 - rb::playback::flush_and_reload_tracks(); 394 394 - drop(player_mutex); 395 395 - Ok(()) 396 396 - } 397 397 - 398 398 - pub async fn resume(ctx: &Context, _req: &Request, _res: &mut Response) -> Result<(), Error> { 399 399 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 400 400 - let player = ctx.player.lock().unwrap(); 401 401 - 402 402 - match player.as_deref() { 403 403 - Some(player) => { 404 404 - player.play().await?; 405 405 - } 406 406 - None => { 407 407 - rb::playback::resume(); 408 408 - } 409 409 - } 410 410 - 411 411 - drop(player_mutex); 412 412 - 413 413 - Ok(()) 414 414 - } 415 415 - 416 416 - pub async fn next(ctx: &Context, _req: &Request, _res: &mut Response) -> Result<(), Error> { 417 417 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 418 418 - // Always advance the Rockbox playlist regardless of active player (e.g. 419 419 - // Chromecast). The Cast monitor loop detects the track change and reloads. 420 420 - rb::playback::next(); 421 421 - drop(player_mutex); 422 422 - let _ = ctx; 423 423 - Ok(()) 424 424 - } 425 425 - 426 426 - pub async fn previous(ctx: &Context, _req: &Request, _res: &mut Response) -> Result<(), Error> { 427 427 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 428 428 - rb::playback::prev(); 429 429 - drop(player_mutex); 430 430 - let _ = ctx; 431 431 - Ok(()) 432 432 - } 433 433 - 434 434 - pub async fn stop(_ctx: &Context, _req: &Request, _res: &mut Response) -> Result<(), Error> { 435 435 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 436 436 - 437 437 - rb::playback::hard_stop(); 438 438 - 439 439 - drop(player_mutex); 440 440 - 441 441 - Ok(()) 442 442 - } 443 443 - 444 444 - pub async fn get_file_position( 445 445 - _ctx: &Context, 446 446 - _req: &Request, 447 447 - res: &mut Response, 448 448 - ) -> Result<(), Error> { 449 449 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 450 450 - let position = rb::playback::get_file_pos(); 451 451 - res.json(&position); 452 452 - 453 453 - drop(player_mutex); 454 454 - 455 455 - Ok(()) 456 456 - } 457 457 - 458 458 - pub async fn get_volume(_ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 459 459 - const SOUND_VOLUME: i32 = 0; 460 460 - let volume = rb::sound::current(SOUND_VOLUME); 461 461 - let min = rb::sound::min(SOUND_VOLUME); 462 462 - let max = rb::sound::max(SOUND_VOLUME); 463 463 - res.json(&serde_json::json!({ "volume": volume, "min": min, "max": max })); 464 464 - Ok(()) 465 465 - } 466 466 - 467 467 - pub async fn adjust_volume(_ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 468 468 - let req_body = req.body.as_ref().unwrap(); 469 469 - let new_volume: NewVolume = serde_json::from_str(&req_body).unwrap(); 470 470 - 471 471 - rb::sound::adjust_volume(new_volume.steps); 472 472 - res.json(&new_volume); 473 473 - Ok(()) 474 474 - } 475 475 - 476 476 - pub async fn get_current_player( 477 477 - ctx: &Context, 478 478 - _req: &Request, 479 479 - res: &mut Response, 480 480 - ) -> Result<(), Error> { 481 481 - let device = ctx.current_device.lock().unwrap(); 482 482 - 483 483 - if let Some(device) = device.as_ref() { 484 484 - res.json(device); 485 485 - return Ok(()); 486 486 - } 487 487 - 488 488 - res.json(&Device { 489 489 - name: "Rockbox (Default Player)".to_string(), 490 490 - app: "default".to_string(), 491 491 - service: "rockbox".to_string(), 492 492 - ..Default::default() 493 493 - }); 494 494 - Ok(()) 495 495 - }

+262 -347

crates/server/src/handlers/playlists.rs

reviewed

··· 1 1 use std::{env, sync::atomic::Ordering, sync::Arc}; 2 2 3 3 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 3 4 use futures_util::stream::{FuturesUnordered, StreamExt}; 4 4 - use tokio::sync::Semaphore; 5 5 - 6 6 - use crate::http::{Context, Request, Response}; 7 7 - use crate::{PLAYER_MUTEX, PLAYLIST_DIRTY}; 8 8 - use anyhow::{anyhow, Error}; 9 5 use local_ip_addr::get_local_ip_address; 10 6 use rand::seq::SliceRandom; 11 11 - use rockbox_graphql::{read_files, read_files_with_art}; 7 7 + use rockbox_graphql::read_files_with_art; 12 8 use rockbox_library::audio_scan::save_audio_metadata; 13 9 use rockbox_library::repo; 14 10 use rockbox_sys::{ ··· 18 14 }; 19 15 use rockbox_traits::types::track::Track; 20 16 use rockbox_types::{DeleteTracks, InsertTracks, NewPlaylist, StatusCode}; 17 17 + use serde::Deserialize; 18 18 + use tokio::sync::Semaphore; 19 19 + 20 20 + use crate::{http::AppState, PLAYER_MUTEX, PLAYLIST_DIRTY}; 21 21 + 22 22 + type HandlerResult = actix_web::Result<HttpResponse>; 21 23 22 24 fn trim_path(s: String) -> String { 23 25 let s = s.trim(); ··· 25 27 } 26 28 27 29 pub async fn create_playlist( 28 28 - _ctx: &Context, 29 29 - req: &Request, 30 30 - res: &mut Response, 31 31 - ) -> Result<(), Error> { 32 32 - if req.body.is_none() { 33 33 - res.set_status(400); 34 34 - return Ok(()); 35 35 - } 36 36 - let body = req.body.as_ref().unwrap(); 37 37 - let mut new_playlist: NewPlaylist = serde_json::from_str(body).unwrap(); 30 30 + state: web::Data<AppState>, 31 31 + body: web::Json<NewPlaylist>, 32 32 + ) -> HandlerResult { 33 33 + let mut new_playlist = body.into_inner(); 38 34 new_playlist.tracks = new_playlist.tracks.into_iter().map(trim_path).collect(); 39 35 40 36 if new_playlist.tracks.is_empty() { 41 41 - return Ok(()); 37 37 + return Ok(HttpResponse::Ok().finish()); 42 38 } 43 39 44 40 let tracks_with_art: Vec<(String, Option<String>)> = new_playlist ··· 46 42 .iter() 47 43 .map(|t| (t.clone(), None)) 48 44 .collect(); 49 49 - persist_remote_track_metadata(_ctx.pool.clone(), tracks_with_art).await; 45 45 + persist_remote_track_metadata(state.pool.clone(), tracks_with_art).await; 50 46 51 51 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 47 47 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 52 48 53 53 - // For HTTP streams: flush the audio thread's message queue before replacing 54 54 - // the playlist. Stale Q_AUDIO_FILL_BUFFER messages from a previous HTTP 55 55 - // session (e.g. auto-resume) would otherwise act on the new playlist's 56 56 - // handle with the old stream context, causing the new play to be silently 57 57 - // ignored. For local files the queue is always drained by the time the 58 58 - // user starts a new playlist, so hard_stop is a no-op cost there. 59 49 let current_is_http = rb::playback::current_track() 60 50 .map(|t| t.path.starts_with("http://") || t.path.starts_with("https://")) 61 51 .unwrap_or(false); ··· 65 55 rb::playback::hard_stop(); 66 56 } 67 57 68 68 - // Always create a fresh playlist so the currently-playing track is 69 69 - // fully replaced rather than appended to. 70 70 - // Local paths: use the track's parent directory (required by Rockbox). 71 71 - // HTTP URLs: use the home directory — "/" fails because it isn't writable 72 72 - // and playlist_create needs to create its control file there. 73 58 let first = &new_playlist.tracks[0]; 74 59 let dir = if first.starts_with("http://") || first.starts_with("https://") { 75 60 std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string()) ··· 79 64 }; 80 65 rb::playlist::create(&dir, None); 81 66 82 82 - // URLs are passed as-is; codec detection happens in the C metadata layer 83 83 - // via probe_content_type_format(), which reads the HTTP Content-Type header 84 84 - // and overrides any extension-based guess. 85 67 let start_index = rb::playlist::build_playlist( 86 68 new_playlist.tracks.iter().map(|t| t.as_str()).collect(), 87 69 0, 88 70 new_playlist.tracks.len() as i32, 89 71 ); 90 72 PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 91 91 - res.text(&start_index.to_string()); 92 92 - drop(player_mutex); 93 93 - Ok(()) 73 73 + Ok(HttpResponse::Ok().body(start_index.to_string())) 94 74 } 95 75 96 96 - pub async fn start_playlist( 97 97 - _ctx: &Context, 98 98 - req: &Request, 99 99 - _res: &mut Response, 100 100 - ) -> Result<(), Error> { 101 101 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 102 102 - let start_index = match req.query_params.get("start_index") { 103 103 - Some(start_index) => start_index.as_str().unwrap_or("0").parse().unwrap_or(0), 104 104 - None => 0, 105 105 - }; 106 106 - let elapsed = match req.query_params.get("elapsed") { 107 107 - Some(elapsed) => elapsed.as_str().unwrap_or("0").parse().unwrap_or(0), 108 108 - None => 0, 109 109 - }; 110 110 - let offset = match req.query_params.get("offset") { 111 111 - Some(offset) => offset.as_str().unwrap_or("0").parse().unwrap_or(0), 112 112 - None => 0, 113 113 - }; 114 114 - rb::playlist::start(start_index, elapsed, offset); 115 115 - PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 116 116 - drop(player_mutex); 117 117 - Ok(()) 76 76 + #[derive(Deserialize)] 77 77 + pub struct StartPlaylistQuery { 78 78 + start_index: Option<i32>, 79 79 + elapsed: Option<u64>, 80 80 + offset: Option<u64>, 118 81 } 119 82 120 120 - pub async fn shuffle_playlist( 121 121 - _ctx: &Context, 122 122 - req: &Request, 123 123 - res: &mut Response, 124 124 - ) -> Result<(), Error> { 125 125 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 126 126 - let start_index = match req.query_params.get("start_index") { 127 127 - Some(start_index) => start_index.as_str().unwrap_or("0").parse().unwrap_or(0), 128 128 - None => 0, 129 129 - }; 130 130 - let seed = rb::system::current_tick(); 131 131 - let ret = rb::playlist::shuffle(seed as i32, start_index as i32); 132 132 - res.text(&ret.to_string()); 133 133 - PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 134 134 - drop(player_mutex); 135 135 - Ok(()) 83 83 + pub async fn start_playlist(query: web::Query<StartPlaylistQuery>) -> HandlerResult { 84 84 + let start_index = query.start_index.unwrap_or(0); 85 85 + let elapsed = query.elapsed.unwrap_or(0); 86 86 + let offset = query.offset.unwrap_or(0); 87 87 + web::block(move || { 88 88 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 89 89 + rb::playlist::start(start_index, elapsed, offset); 90 90 + PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 91 91 + }) 92 92 + .await 93 93 + .map_err(ErrorInternalServerError)?; 94 94 + Ok(HttpResponse::Ok().finish()) 136 95 } 137 96 138 138 - pub async fn get_playlist_amount( 139 139 - _ctx: &Context, 140 140 - _req: &Request, 141 141 - res: &mut Response, 142 142 - ) -> Result<(), Error> { 143 143 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 144 144 - let amount = rb::playlist::amount(); 145 145 - res.json(&PlaylistAmount { amount }); 146 146 - drop(player_mutex); 147 147 - Ok(()) 97 97 + #[derive(Deserialize)] 98 98 + pub struct ShuffleQuery { 99 99 + start_index: Option<i32>, 148 100 } 149 101 150 150 - pub async fn resume_playlist( 151 151 - _ctx: &Context, 152 152 - _req: &Request, 153 153 - res: &mut Response, 154 154 - ) -> Result<(), Error> { 155 155 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 156 156 - let status = rb::system::get_global_status(); 157 157 - let playback_status = rb::playback::status(); 102 102 + pub async fn shuffle_playlist(query: web::Query<ShuffleQuery>) -> HandlerResult { 103 103 + let start_index = query.start_index.unwrap_or(0); 104 104 + let ret = web::block(move || { 105 105 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 106 106 + let seed = rb::system::current_tick(); 107 107 + let ret = rb::playlist::shuffle(seed as i32, start_index); 108 108 + PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 109 109 + ret 110 110 + }) 111 111 + .await 112 112 + .map_err(ErrorInternalServerError)?; 113 113 + Ok(HttpResponse::Ok().body(ret.to_string())) 114 114 + } 158 115 159 159 - if status.resume_index == -1 || playback_status.status == 1 { 160 160 - res.json(&StatusCode { code: -1 }); 161 161 - return Ok(()); 162 162 - } 116 116 + pub async fn get_playlist_amount() -> HandlerResult { 117 117 + let amount = web::block(|| { 118 118 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 119 119 + rb::playlist::amount() 120 120 + }) 121 121 + .await 122 122 + .map_err(ErrorInternalServerError)?; 123 123 + Ok(HttpResponse::Ok().json(PlaylistAmount { amount })) 124 124 + } 163 125 164 164 - let code = rb::playlist::resume(); 165 165 - res.json(&StatusCode { code }); 166 166 - PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 167 167 - drop(player_mutex); 168 168 - Ok(()) 126 126 + pub async fn resume_playlist() -> HandlerResult { 127 127 + let code = web::block(|| { 128 128 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 129 129 + let status = rb::system::get_global_status(); 130 130 + let playback_status = rb::playback::status(); 131 131 + if status.resume_index == -1 || playback_status.status == 1 { 132 132 + return -1; 133 133 + } 134 134 + let code = rb::playlist::resume(); 135 135 + PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 136 136 + code 137 137 + }) 138 138 + .await 139 139 + .map_err(ErrorInternalServerError)?; 140 140 + Ok(HttpResponse::Ok().json(StatusCode { code })) 169 141 } 170 142 171 171 - pub async fn resume_track( 172 172 - _ctx: &Context, 173 173 - _req: &Request, 174 174 - _res: &mut Response, 175 175 - ) -> Result<(), Error> { 176 176 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 177 177 - let status = rb::system::get_global_status(); 178 178 - if status.resume_index == -1 { 179 179 - return Ok(()); 180 180 - } 181 181 - // Rebuild playlist from control file if not already loaded — matches the 182 182 - // root_menu.c pattern: playlist_resume() then playlist_resume_track(). 183 183 - if rb::playlist::amount() == 0 { 184 184 - let ret = rb::playlist::resume(); 185 185 - if ret == -1 { 186 186 - return Ok(()); 143 143 + pub async fn resume_track() -> HandlerResult { 144 144 + web::block(|| { 145 145 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 146 146 + let status = rb::system::get_global_status(); 147 147 + if status.resume_index == -1 { 148 148 + return; 187 149 } 188 188 - } 189 189 - rb::playlist::resume_track( 190 190 - status.resume_index, 191 191 - status.resume_crc32, 192 192 - status.resume_elapsed.into(), 193 193 - status.resume_offset.into(), 194 194 - ); 195 195 - PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 196 196 - drop(player_mutex); 197 197 - Ok(()) 150 150 + if rb::playlist::amount() == 0 { 151 151 + let ret = rb::playlist::resume(); 152 152 + if ret == -1 { 153 153 + return; 154 154 + } 155 155 + } 156 156 + rb::playlist::resume_track( 157 157 + status.resume_index, 158 158 + status.resume_crc32, 159 159 + status.resume_elapsed.into(), 160 160 + status.resume_offset.into(), 161 161 + ); 162 162 + PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 163 163 + }) 164 164 + .await 165 165 + .map_err(ErrorInternalServerError)?; 166 166 + Ok(HttpResponse::Ok().finish()) 198 167 } 199 168 200 200 - pub async fn get_playlist_tracks( 201 201 - _ctx: &Context, 202 202 - _req: &Request, 203 203 - res: &mut Response, 204 204 - ) -> Result<(), Error> { 205 205 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 206 206 - let mut entries = vec![]; 207 207 - let amount = rb::playlist::amount(); 208 208 - 209 209 - for i in 0..amount { 210 210 - let info = rb::playlist::get_track_info(i); 211 211 - let entry = rb::metadata::get_metadata(-1, &info.filename); 212 212 - entries.push(entry); 213 213 - } 214 214 - 215 215 - res.json(&entries); 216 216 - 217 217 - drop(player_mutex); 218 218 - Ok(()) 169 169 + pub async fn get_playlist_tracks(_path: web::Path<String>) -> HandlerResult { 170 170 + let entries = web::block(|| { 171 171 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 172 172 + let amount = rb::playlist::amount(); 173 173 + let mut entries = Vec::with_capacity(amount as usize); 174 174 + for i in 0..amount { 175 175 + let info = rb::playlist::get_track_info(i); 176 176 + entries.push(rb::metadata::get_metadata(-1, &info.filename)); 177 177 + } 178 178 + entries 179 179 + }) 180 180 + .await 181 181 + .map_err(ErrorInternalServerError)?; 182 182 + Ok(HttpResponse::Ok().json(entries)) 219 183 } 220 184 221 221 - pub async fn insert_tracks(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 222 222 - let req_body = req.body.as_ref().unwrap(); 223 223 - let mut tracklist: InsertTracks = serde_json::from_str(&req_body).unwrap(); 185 185 + pub async fn insert_tracks( 186 186 + state: web::Data<AppState>, 187 187 + _path: web::Path<String>, 188 188 + body: web::Json<InsertTracks>, 189 189 + ) -> HandlerResult { 190 190 + let mut tracklist = body.into_inner(); 224 191 tracklist.tracks = tracklist.tracks.into_iter().map(trim_path).collect(); 225 192 226 193 let mut tracks_with_art: Vec<(String, Option<String>)> = 227 194 tracklist.tracks.iter().map(|t| (t.clone(), None)).collect(); 228 195 229 196 if let Some(dir) = &tracklist.directory { 230 230 - let entries = read_files_with_art(dir.clone()).await?; 197 197 + let entries = read_files_with_art(dir.clone()) 198 198 + .await 199 199 + .map_err(ErrorInternalServerError)?; 231 200 tracklist.tracks = entries.iter().map(|(uri, _)| uri.clone()).collect(); 232 201 tracks_with_art = entries; 233 202 } 234 203 235 204 if tracklist.tracks.is_empty() { 236 236 - res.text("0"); 237 237 - return Ok(()); 205 205 + return Ok(HttpResponse::Ok().body("0")); 238 206 } 239 207 240 240 - persist_remote_track_metadata(ctx.pool.clone(), tracks_with_art).await; 208 208 + persist_remote_track_metadata(state.pool.clone(), tracks_with_art).await; 241 209 242 242 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 210 210 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 243 211 let amount = rb::playlist::amount(); 244 244 - 245 245 - let mut player = ctx.player.lock().unwrap(); 212 212 + let mut player = state.player.lock().unwrap(); 246 213 247 214 if let Some(player) = player.as_deref_mut() { 248 248 - let kv = ctx.kv.lock().unwrap(); 215 215 + let kv = state.kv.lock().unwrap(); 249 216 let rockbox_addr = 250 217 env::var("ROCKBOX_ADDR").unwrap_or_else(|_| get_local_ip_address().unwrap()); 251 218 let rockbox_port = env::var("ROCKBOX_GRAPHQL_PORT").unwrap_or_else(|_| "6062".to_string()); ··· 281 248 .collect::<Vec<Track>>(); 282 249 283 250 for track in tracks { 284 284 - player.play_next(track).await?; 251 251 + player 252 252 + .play_next(track) 253 253 + .await 254 254 + .map_err(ErrorInternalServerError)?; 285 255 } 286 256 287 287 - res.text("0"); 288 288 - return Ok(()); 257 257 + return Ok(HttpResponse::Ok().body("0")); 289 258 } 290 259 291 260 if amount == 0 { ··· 298 267 }; 299 268 let status = rb::playlist::create(&dir, None); 300 269 if status == -1 { 301 301 - res.set_status(500); 302 302 - res.text("Failed to create playlist"); 303 303 - return Ok(()); 270 270 + return Ok(HttpResponse::InternalServerError().body("Failed to create playlist")); 304 271 } 305 305 - let start_index = 0; 306 272 let start_index = rb::playlist::build_playlist( 307 273 tracklist.tracks.iter().map(|t| t.as_str()).collect(), 308 308 - start_index, 274 274 + 0, 309 275 tracklist.tracks.len() as i32, 310 276 ); 311 311 - res.text(&start_index.to_string()); 312 277 PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 313 313 - return Ok(()); 278 278 + return Ok(HttpResponse::Ok().body(start_index.to_string())); 314 279 } 315 280 316 281 let mut tracks: Vec<&str> = tracklist.tracks.iter().map(|t| t.as_str()).collect(); ··· 323 288 }; 324 289 rb::playlist::insert_tracks(tracks, position, tracklist.tracks.len() as i32); 325 290 326 326 - res.text(&tracklist.position.to_string()); 291 291 + PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 292 292 + Ok(HttpResponse::Ok().body(tracklist.position.to_string())) 293 293 + } 294 294 + 295 295 + pub async fn remove_tracks( 296 296 + state: web::Data<AppState>, 297 297 + _path: web::Path<String>, 298 298 + body: web::Json<DeleteTracks>, 299 299 + ) -> HandlerResult { 300 300 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 301 301 + let player = state.player.lock().unwrap(); 302 302 + 303 303 + if player.as_deref().is_some() { 304 304 + return Ok(HttpResponse::Ok().body("0")); 305 305 + } 306 306 + 307 307 + let params = body.into_inner(); 308 308 + let mut ret = 0; 309 309 + 310 310 + for position in &params.positions { 311 311 + ret = rb::playlist::delete_track(*position); 312 312 + } 313 313 + 314 314 + if params.positions.is_empty() { 315 315 + ret = rb::playlist::remove_all_tracks(); 316 316 + PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 317 317 + return Ok(HttpResponse::Ok().body(ret.to_string())); 318 318 + } 319 319 + 327 320 PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 328 328 - drop(player_mutex); 321 321 + Ok(HttpResponse::Ok().body(ret.to_string())) 322 322 + } 323 323 + 324 324 + pub async fn get_playlist(state: web::Data<AppState>, _path: web::Path<String>) -> HandlerResult { 325 325 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 326 326 + let mut player = state.player.lock().unwrap(); 329 327 330 330 - Ok(()) 328 328 + if let Some(player) = player.as_deref_mut() { 329 329 + let current_playback = player 330 330 + .get_current_playback() 331 331 + .await 332 332 + .map_err(ErrorInternalServerError)?; 333 333 + let tracks = current_playback.items; 334 334 + let index = match tracks.len() >= 2 { 335 335 + true => tracks.len() - 2, 336 336 + false => 0, 337 337 + } as i32; 338 338 + 339 339 + let mut entries = Vec::with_capacity(tracks.len()); 340 340 + for (mut track, _) in tracks { 341 341 + if track.path.is_empty() { 342 342 + track.path = track.uri.clone(); 343 343 + } 344 344 + 345 345 + let mut entry: rockbox_sys::types::mp3_entry::Mp3Entry = track.into(); 346 346 + if !entry.path.is_empty() { 347 347 + if let Some(metadata) = find_track_metadata(&state, &entry.path) 348 348 + .await 349 349 + .map_err(ErrorInternalServerError)? 350 350 + { 351 351 + entry.id = Some(metadata.id); 352 352 + entry.album_art = metadata.album_art.or(entry.album_art.clone()); 353 353 + entry.album_id = Some(metadata.album_id); 354 354 + entry.artist_id = Some(metadata.artist_id); 355 355 + entry.genre_id = Some(metadata.genre_id); 356 356 + } 357 357 + } 358 358 + 359 359 + entries.push(entry); 360 360 + } 361 361 + 362 362 + let result = PlaylistInfo { 363 363 + amount: entries.len() as i32, 364 364 + index, 365 365 + entries, 366 366 + ..Default::default() 367 367 + }; 368 368 + return Ok(HttpResponse::Ok().json(result)); 369 369 + } 370 370 + 371 371 + let mut metadata_cache = state.metadata_cache.lock().await; 372 372 + let mut result = rb::playlist::get_current(); 373 373 + let mut entries = vec![]; 374 374 + let amount = rb::playlist::amount(); 375 375 + 376 376 + for i in 0..amount { 377 377 + let info = rb::playlist::get_track_info(i); 378 378 + let mut entry = rb::metadata::get_metadata(-1, &info.filename); 379 379 + let hash = format!("{:x}", md5::compute(info.filename.as_bytes())); 380 380 + 381 381 + if let Some(cached) = metadata_cache.get(&hash) { 382 382 + entries.push(cached.clone()); 383 383 + continue; 384 384 + } 385 385 + 386 386 + let track = find_track_metadata(&state, &info.filename) 387 387 + .await 388 388 + .map_err(ErrorInternalServerError)?; 389 389 + 390 390 + if track.is_none() { 391 391 + entries.push(entry.clone()); 392 392 + continue; 393 393 + } 394 394 + 395 395 + entry.album_art = track.as_ref().and_then(|t| t.album_art.clone()); 396 396 + entry.album_id = track.as_ref().map(|t| t.album_id.clone()); 397 397 + entry.artist_id = track.as_ref().map(|t| t.artist_id.clone()); 398 398 + entry.genre_id = track.as_ref().map(|t| t.genre_id.clone()); 399 399 + entry.id = track.as_ref().map(|t| t.id.clone()); 400 400 + 401 401 + metadata_cache.insert(hash, entry.clone()); 402 402 + entries.push(entry); 403 403 + } 404 404 + 405 405 + result.amount = amount; 406 406 + result.max_playlist_size = rb::playlist::max_playlist_size(); 407 407 + result.index = rb::playlist::index(); 408 408 + result.first_index = rb::playlist::first_index(); 409 409 + result.last_insert_pos = rb::playlist::last_insert_pos(); 410 410 + result.seed = rb::playlist::seed(); 411 411 + result.last_shuffled_start = rb::playlist::last_shuffled_start(); 412 412 + result.entries = entries; 413 413 + 414 414 + Ok(HttpResponse::Ok().json(result)) 331 415 } 332 416 333 417 async fn persist_remote_track_metadata( 334 418 pool: sqlx::Pool<sqlx::Sqlite>, 335 419 tracks: Vec<(String, Option<String>)>, 336 420 ) { 337 337 - // Raw PCM streams served at /stream.wav have no embedded metadata and 338 338 - // probing them would block for ~47 s (8 MB at audio bitrate) then time out. 339 421 let sem = Arc::new(Semaphore::new(8)); 340 422 let mut futs: FuturesUnordered<tokio::task::JoinHandle<()>> = FuturesUnordered::new(); 341 423 ··· 349 431 { 350 432 continue; 351 433 } 352 352 - // Internal /tracks/{id} URLs are already in the library DB. 353 434 match find_internal_track_by_pool(&pool, &track).await { 354 435 Ok(Some(_)) => continue, 355 436 Ok(None) => {} ··· 372 453 } 373 454 374 455 async fn find_track_metadata( 375 375 - ctx: &Context, 456 456 + state: &AppState, 376 457 path: &str, 377 377 - ) -> Result<Option<rockbox_library::entity::track::Track>, Error> { 458 458 + ) -> Result<Option<rockbox_library::entity::track::Track>, anyhow::Error> { 378 459 let hash = format!("{:x}", md5::compute(path.as_bytes())); 379 379 - let mut metadata = repo::track::find_by_md5(ctx.pool.clone(), &hash).await?; 380 380 - let internal_track = find_internal_track_by_url(ctx, path).await?; 460 460 + let mut metadata = repo::track::find_by_md5(state.pool.clone(), &hash).await?; 461 461 + let internal_track = find_internal_track_by_url(state, path).await?; 381 462 382 463 if metadata 383 464 .as_ref() ··· 389 470 } 390 471 } 391 472 392 392 - // Metadata for remote tracks is probed in the background when tracks are 393 393 - // inserted (insert_tracks / create_playlist). Do not probe here — this 394 394 - // function is called once per track while holding PLAYER_MUTEX, so a 395 395 - // synchronous HTTP probe per track would block the entire server. 396 396 - 397 473 Ok(metadata) 398 474 } 399 475 400 476 async fn find_internal_track_by_url( 401 401 - ctx: &Context, 477 477 + state: &AppState, 402 478 path: &str, 403 403 - ) -> Result<Option<rockbox_library::entity::track::Track>, Error> { 404 404 - find_internal_track_by_pool(&ctx.pool, path).await 479 479 + ) -> Result<Option<rockbox_library::entity::track::Track>, anyhow::Error> { 480 480 + find_internal_track_by_pool(&state.pool, path).await 405 481 } 406 482 407 483 async fn find_internal_track_by_pool( 408 484 pool: &sqlx::Pool<sqlx::Sqlite>, 409 485 path: &str, 410 410 - ) -> Result<Option<rockbox_library::entity::track::Track>, Error> { 486 486 + ) -> Result<Option<rockbox_library::entity::track::Track>, anyhow::Error> { 411 487 let url = match reqwest::Url::parse(path) { 412 488 Ok(url) => url, 413 489 Err(_) => return Ok(None), ··· 433 509 .await 434 510 .map_err(Into::into) 435 511 } 436 436 - 437 437 - pub async fn remove_tracks(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 438 438 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 439 439 - let player = ctx.player.lock().unwrap(); 440 440 - 441 441 - if let Some(_) = player.as_deref() { 442 442 - res.text("0"); 443 443 - return Ok(()); 444 444 - } 445 445 - 446 446 - let req_body = req.body.as_ref().unwrap(); 447 447 - let params = serde_json::from_str::<DeleteTracks>(&req_body)?; 448 448 - let mut ret = 0; 449 449 - 450 450 - for position in &params.positions { 451 451 - ret = rb::playlist::delete_track(position.clone()); 452 452 - } 453 453 - 454 454 - if params.positions.is_empty() { 455 455 - ret = rb::playlist::remove_all_tracks(); 456 456 - res.text(&ret.to_string()); 457 457 - PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 458 458 - return Ok(()); 459 459 - } 460 460 - 461 461 - res.text(&ret.to_string()); 462 462 - PLAYLIST_DIRTY.store(true, Ordering::Relaxed); 463 463 - drop(player_mutex); 464 464 - Ok(()) 465 465 - } 466 466 - 467 467 - pub async fn current_playlist( 468 468 - ctx: &Context, 469 469 - _req: &Request, 470 470 - res: &mut Response, 471 471 - ) -> Result<(), Error> { 472 472 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 473 473 - let mut metadata_cache = ctx.metadata_cache.lock().await; 474 474 - let mut entries = vec![]; 475 475 - let amount = rb::playlist::amount(); 476 476 - 477 477 - for i in 0..amount { 478 478 - let info = rb::playlist::get_track_info(i); 479 479 - let mut entry = rb::metadata::get_metadata(-1, &info.filename); 480 480 - let hash = format!("{:x}", md5::compute(info.filename.as_bytes())); 481 481 - 482 482 - if let Some(entry) = metadata_cache.get(&hash) { 483 483 - entries.push(entry.clone()); 484 484 - continue; 485 485 - } 486 486 - 487 487 - let track = find_track_metadata(ctx, &info.filename).await?; 488 488 - 489 489 - if track.is_none() { 490 490 - entries.push(entry.clone()); 491 491 - continue; 492 492 - } 493 493 - 494 494 - entry.album_art = track.as_ref().map(|t| t.album_art.clone()).flatten(); 495 495 - entry.album_id = track.as_ref().map(|t| t.album_id.clone()); 496 496 - entry.artist_id = track.as_ref().map(|t| t.artist_id.clone()); 497 497 - entry.genre_id = track.as_ref().map(|t| t.genre_id.clone()); 498 498 - entry.id = track.as_ref().map(|t| t.id.clone()); 499 499 - 500 500 - metadata_cache.insert(hash, entry.clone()); 501 501 - entries.push(entry); 502 502 - } 503 503 - 504 504 - res.json(&entries); 505 505 - 506 506 - drop(player_mutex); 507 507 - Ok(()) 508 508 - } 509 509 - 510 510 - pub async fn get_playlist(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 511 511 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 512 512 - let mut player = ctx.player.lock().unwrap(); 513 513 - 514 514 - if let Some(player) = player.as_deref_mut() { 515 515 - let current_playback = player.get_current_playback().await?; 516 516 - let tracks = current_playback.items; 517 517 - let index = match tracks.len() >= 2 { 518 518 - true => tracks.len() - 2, 519 519 - false => 0, 520 520 - } as i32; 521 521 - 522 522 - let mut entries = Vec::with_capacity(tracks.len()); 523 523 - for (mut track, _) in tracks { 524 524 - if track.path.is_empty() { 525 525 - track.path = track.uri.clone(); 526 526 - } 527 527 - 528 528 - let mut entry: rockbox_sys::types::mp3_entry::Mp3Entry = track.into(); 529 529 - if !entry.path.is_empty() { 530 530 - if let Some(metadata) = find_track_metadata(ctx, &entry.path).await? { 531 531 - entry.id = Some(metadata.id); 532 532 - entry.album_art = metadata.album_art.or(entry.album_art.clone()); 533 533 - entry.album_id = Some(metadata.album_id); 534 534 - entry.artist_id = Some(metadata.artist_id); 535 535 - entry.genre_id = Some(metadata.genre_id); 536 536 - } 537 537 - } 538 538 - 539 539 - entries.push(entry); 540 540 - } 541 541 - 542 542 - let result = PlaylistInfo { 543 543 - amount: entries.len() as i32, 544 544 - index, 545 545 - entries, 546 546 - ..Default::default() 547 547 - }; 548 548 - res.json(&result); 549 549 - return Ok(()); 550 550 - } 551 551 - 552 552 - let mut metadata_cache = ctx.metadata_cache.lock().await; 553 553 - let mut result = rb::playlist::get_current(); 554 554 - let mut entries = vec![]; 555 555 - let amount = rb::playlist::amount(); 556 556 - 557 557 - for i in 0..amount { 558 558 - let info = rb::playlist::get_track_info(i); 559 559 - let mut entry = rb::metadata::get_metadata(-1, &info.filename); 560 560 - let hash = format!("{:x}", md5::compute(info.filename.as_bytes())); 561 561 - 562 562 - if let Some(entry) = metadata_cache.get(&hash) { 563 563 - entries.push(entry.clone()); 564 564 - continue; 565 565 - } 566 566 - 567 567 - let track = find_track_metadata(ctx, &info.filename).await?; 568 568 - 569 569 - if track.is_none() { 570 570 - entries.push(entry.clone()); 571 571 - continue; 572 572 - } 573 573 - 574 574 - entry.album_art = track.as_ref().map(|t| t.album_art.clone()).flatten(); 575 575 - entry.album_id = track.as_ref().map(|t| t.album_id.clone()); 576 576 - entry.artist_id = track.as_ref().map(|t| t.artist_id.clone()); 577 577 - entry.genre_id = track.as_ref().map(|t| t.genre_id.clone()); 578 578 - entry.id = track.as_ref().map(|t| t.id.clone()); 579 579 - 580 580 - metadata_cache.insert(hash, entry.clone()); 581 581 - entries.push(entry); 582 582 - } 583 583 - 584 584 - result.amount = amount; 585 585 - result.max_playlist_size = rb::playlist::max_playlist_size(); 586 586 - result.index = rb::playlist::index(); 587 587 - result.first_index = rb::playlist::first_index(); 588 588 - result.last_insert_pos = rb::playlist::last_insert_pos(); 589 589 - result.seed = rb::playlist::seed(); 590 590 - result.last_shuffled_start = rb::playlist::last_shuffled_start(); 591 591 - result.entries = entries; 592 592 - 593 593 - res.json(&result); 594 594 - drop(player_mutex); 595 595 - Ok(()) 596 596 - }

+173 -178

crates/server/src/handlers/saved_playlists.rs

reviewed

··· 1 1 - use crate::http::{Context, Request, Response}; 2 2 - use crate::PLAYER_MUTEX; 3 3 - use anyhow::Error; 1 1 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 4 2 use rockbox_library::repo; 5 3 use rockbox_sys::{self as rb}; 6 4 use serde::Deserialize; 7 5 6 6 + use crate::{http::AppState, PLAYER_MUTEX}; 7 7 + 8 8 + type HandlerResult = actix_web::Result<HttpResponse>; 9 9 + 8 10 #[derive(Deserialize)] 9 9 - struct CreatePlaylistBody { 11 11 + pub struct CreatePlaylistBody { 10 12 name: String, 11 13 description: Option<String>, 12 14 image: Option<String>, ··· 15 17 } 16 18 17 19 #[derive(Deserialize)] 18 18 - struct UpdatePlaylistBody { 20 20 + pub struct UpdatePlaylistBody { 19 21 name: String, 20 22 description: Option<String>, 21 23 image: Option<String>, ··· 23 25 } 24 26 25 27 #[derive(Deserialize)] 26 26 - struct AddTracksBody { 28 28 + pub struct AddTracksBody { 27 29 track_ids: Vec<String>, 28 30 } 29 31 30 32 #[derive(Deserialize)] 31 31 - struct CreateFolderBody { 33 33 + pub struct CreateFolderBody { 32 34 name: String, 33 35 } 34 36 35 35 - pub async fn list_saved_playlists( 36 36 - ctx: &Context, 37 37 - req: &Request, 38 38 - res: &mut Response, 39 39 - ) -> Result<(), Error> { 40 40 - let folder_id = req 41 41 - .query_params 42 42 - .get("folder_id") 43 43 - .and_then(|v| v.as_str()) 44 44 - .map(|s| s.to_string()); 37 37 + #[derive(Deserialize)] 38 38 + pub struct ListQuery { 39 39 + folder_id: Option<String>, 40 40 + } 45 41 46 46 - let playlists = match folder_id.as_deref() { 47 47 - Some(fid) if !fid.is_empty() => ctx.playlist_store.list_by_folder(fid).await?, 48 48 - _ => ctx.playlist_store.list().await?, 42 42 + pub async fn list_saved_playlists( 43 43 + state: web::Data<AppState>, 44 44 + query: web::Query<ListQuery>, 45 45 + ) -> HandlerResult { 46 46 + let playlists = match query.folder_id.as_deref() { 47 47 + Some(fid) if !fid.is_empty() => state 48 48 + .playlist_store 49 49 + .list_by_folder(fid) 50 50 + .await 51 51 + .map_err(ErrorInternalServerError)?, 52 52 + _ => state 53 53 + .playlist_store 54 54 + .list() 55 55 + .await 56 56 + .map_err(ErrorInternalServerError)?, 49 57 }; 50 50 - res.json(&playlists); 51 51 - Ok(()) 58 58 + Ok(HttpResponse::Ok().json(playlists)) 52 59 } 53 60 54 61 pub async fn get_saved_playlist( 55 55 - ctx: &Context, 56 56 - req: &Request, 57 57 - res: &mut Response, 58 58 - ) -> Result<(), Error> { 59 59 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 60 60 - match ctx.playlist_store.get(id).await? { 61 61 - Some(p) => res.json(&p), 62 62 - None => res.set_status(404), 62 62 + state: web::Data<AppState>, 63 63 + path: web::Path<String>, 64 64 + ) -> HandlerResult { 65 65 + let id = path.into_inner(); 66 66 + match state 67 67 + .playlist_store 68 68 + .get(&id) 69 69 + .await 70 70 + .map_err(ErrorInternalServerError)? 71 71 + { 72 72 + Some(p) => Ok(HttpResponse::Ok().json(p)), 73 73 + None => Ok(HttpResponse::NotFound().finish()), 63 74 } 64 64 - Ok(()) 65 75 } 66 76 67 77 pub async fn create_saved_playlist( 68 68 - ctx: &Context, 69 69 - req: &Request, 70 70 - res: &mut Response, 71 71 - ) -> Result<(), Error> { 72 72 - let body = match req.body.as_ref() { 73 73 - Some(b) => b, 74 74 - None => { 75 75 - res.set_status(400); 76 76 - return Ok(()); 77 77 - } 78 78 - }; 79 79 - let payload: CreatePlaylistBody = serde_json::from_str(body)?; 78 78 + state: web::Data<AppState>, 79 79 + body: web::Json<CreatePlaylistBody>, 80 80 + ) -> HandlerResult { 81 81 + let payload = body.into_inner(); 80 82 if payload.name.is_empty() { 81 81 - res.set_status(400); 82 82 - return Ok(()); 83 83 + return Ok(HttpResponse::BadRequest().finish()); 83 84 } 84 85 85 85 - let playlist = ctx 86 86 + let playlist = state 86 87 .playlist_store 87 88 .create( 88 89 &payload.name, ··· 90 91 payload.image.as_deref(), 91 92 payload.folder_id.as_deref(), 92 93 ) 93 93 - .await?; 94 94 + .await 95 95 + .map_err(ErrorInternalServerError)?; 94 96 if let Some(ids) = payload.track_ids { 95 97 if !ids.is_empty() { 96 96 - ctx.playlist_store.add_tracks(&playlist.id, &ids).await?; 98 98 + state 99 99 + .playlist_store 100 100 + .add_tracks(&playlist.id, &ids) 101 101 + .await 102 102 + .map_err(ErrorInternalServerError)?; 97 103 } 98 104 } 99 99 - let playlist = ctx 105 105 + let playlist = state 100 106 .playlist_store 101 107 .get(&playlist.id) 102 102 - .await? 108 108 + .await 109 109 + .map_err(ErrorInternalServerError)? 103 110 .unwrap_or(playlist); 104 104 - res.set_status(201); 105 105 - res.json(&playlist); 106 106 - Ok(()) 111 111 + Ok(HttpResponse::Created().json(playlist)) 107 112 } 108 113 109 114 pub async fn update_saved_playlist( 110 110 - ctx: &Context, 111 111 - req: &Request, 112 112 - res: &mut Response, 113 113 - ) -> Result<(), Error> { 114 114 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 115 115 - let body = match req.body.as_ref() { 116 116 - Some(b) => b, 117 117 - None => { 118 118 - res.set_status(400); 119 119 - return Ok(()); 120 120 - } 121 121 - }; 122 122 - let payload: UpdatePlaylistBody = serde_json::from_str(body)?; 123 123 - ctx.playlist_store 115 115 + state: web::Data<AppState>, 116 116 + path: web::Path<String>, 117 117 + body: web::Json<UpdatePlaylistBody>, 118 118 + ) -> HandlerResult { 119 119 + let id = path.into_inner(); 120 120 + let payload = body.into_inner(); 121 121 + state 122 122 + .playlist_store 124 123 .update( 125 125 - id, 124 124 + &id, 126 125 &payload.name, 127 126 payload.description.as_deref(), 128 127 payload.image.as_deref(), 129 128 payload.folder_id.as_deref(), 130 129 ) 131 131 - .await?; 132 132 - res.set_status(204); 133 133 - Ok(()) 130 130 + .await 131 131 + .map_err(ErrorInternalServerError)?; 132 132 + Ok(HttpResponse::NoContent().finish()) 134 133 } 135 134 136 135 pub async fn delete_saved_playlist( 137 137 - ctx: &Context, 138 138 - req: &Request, 139 139 - res: &mut Response, 140 140 - ) -> Result<(), Error> { 141 141 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 142 142 - ctx.playlist_store.delete(id).await?; 143 143 - res.set_status(204); 144 144 - Ok(()) 136 136 + state: web::Data<AppState>, 137 137 + path: web::Path<String>, 138 138 + ) -> HandlerResult { 139 139 + let id = path.into_inner(); 140 140 + state 141 141 + .playlist_store 142 142 + .delete(&id) 143 143 + .await 144 144 + .map_err(ErrorInternalServerError)?; 145 145 + Ok(HttpResponse::NoContent().finish()) 145 146 } 146 147 147 148 pub async fn get_saved_playlist_tracks( 148 148 - ctx: &Context, 149 149 - req: &Request, 150 150 - res: &mut Response, 151 151 - ) -> Result<(), Error> { 152 152 - let playlist_id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 153 153 - let track_ids = ctx.playlist_store.get_track_ids(playlist_id).await?; 149 149 + state: web::Data<AppState>, 150 150 + path: web::Path<String>, 151 151 + ) -> HandlerResult { 152 152 + let playlist_id = path.into_inner(); 153 153 + let track_ids = state 154 154 + .playlist_store 155 155 + .get_track_ids(&playlist_id) 156 156 + .await 157 157 + .map_err(ErrorInternalServerError)?; 154 158 let mut tracks = Vec::with_capacity(track_ids.len()); 155 159 for id in &track_ids { 156 156 - if let Some(track) = repo::track::find(ctx.pool.clone(), id).await? { 160 160 + if let Some(track) = repo::track::find(state.pool.clone(), id) 161 161 + .await 162 162 + .map_err(ErrorInternalServerError)? 163 163 + { 157 164 tracks.push(track); 158 165 } 159 166 } 160 160 - res.json(&tracks); 161 161 - Ok(()) 167 167 + Ok(HttpResponse::Ok().json(tracks)) 162 168 } 163 169 164 164 - pub async fn add_tracks_to_saved_playlist( 165 165 - ctx: &Context, 166 166 - req: &Request, 167 167 - res: &mut Response, 168 168 - ) -> Result<(), Error> { 169 169 - let playlist_id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 170 170 - let body = match req.body.as_ref() { 171 171 - Some(b) => b, 172 172 - None => { 173 173 - res.set_status(400); 174 174 - return Ok(()); 175 175 - } 176 176 - }; 177 177 - let payload: AddTracksBody = serde_json::from_str(body)?; 178 178 - ctx.playlist_store 179 179 - .add_tracks(playlist_id, &payload.track_ids) 180 180 - .await?; 181 181 - res.set_status(204); 182 182 - Ok(()) 170 170 + pub async fn get_saved_playlist_track_ids( 171 171 + state: web::Data<AppState>, 172 172 + path: web::Path<String>, 173 173 + ) -> HandlerResult { 174 174 + let playlist_id = path.into_inner(); 175 175 + let track_ids = state 176 176 + .playlist_store 177 177 + .get_track_ids(&playlist_id) 178 178 + .await 179 179 + .map_err(ErrorInternalServerError)?; 180 180 + Ok(HttpResponse::Ok().json(track_ids)) 183 181 } 184 182 185 185 - pub async fn get_saved_playlist_track_ids( 186 186 - ctx: &Context, 187 187 - req: &Request, 188 188 - res: &mut Response, 189 189 - ) -> Result<(), Error> { 190 190 - let playlist_id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 191 191 - let track_ids = ctx.playlist_store.get_track_ids(playlist_id).await?; 192 192 - res.json(&track_ids); 193 193 - Ok(()) 183 183 + pub async fn add_tracks_to_saved_playlist( 184 184 + state: web::Data<AppState>, 185 185 + path: web::Path<String>, 186 186 + body: web::Json<AddTracksBody>, 187 187 + ) -> HandlerResult { 188 188 + let playlist_id = path.into_inner(); 189 189 + let payload = body.into_inner(); 190 190 + state 191 191 + .playlist_store 192 192 + .add_tracks(&playlist_id, &payload.track_ids) 193 193 + .await 194 194 + .map_err(ErrorInternalServerError)?; 195 195 + Ok(HttpResponse::NoContent().finish()) 194 196 } 195 197 196 198 pub async fn remove_track_from_saved_playlist( 197 197 - ctx: &Context, 198 198 - req: &Request, 199 199 - res: &mut Response, 200 200 - ) -> Result<(), Error> { 201 201 - let playlist_id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 202 202 - let track_id = req.params.get(1).map(|s| s.as_str()).unwrap_or(""); 203 203 - ctx.playlist_store 204 204 - .remove_track(playlist_id, track_id) 205 205 - .await?; 206 206 - res.set_status(204); 207 207 - Ok(()) 199 199 + state: web::Data<AppState>, 200 200 + path: web::Path<(String, String)>, 201 201 + ) -> HandlerResult { 202 202 + let (playlist_id, track_id) = path.into_inner(); 203 203 + state 204 204 + .playlist_store 205 205 + .remove_track(&playlist_id, &track_id) 206 206 + .await 207 207 + .map_err(ErrorInternalServerError)?; 208 208 + Ok(HttpResponse::NoContent().finish()) 208 209 } 209 210 210 211 pub async fn play_saved_playlist( 211 211 - ctx: &Context, 212 212 - req: &Request, 213 213 - res: &mut Response, 214 214 - ) -> Result<(), Error> { 215 215 - let playlist_id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 216 216 - let track_ids = ctx.playlist_store.get_track_ids(playlist_id).await?; 212 212 + state: web::Data<AppState>, 213 213 + path: web::Path<String>, 214 214 + ) -> HandlerResult { 215 215 + let playlist_id = path.into_inner(); 216 216 + let track_ids = state 217 217 + .playlist_store 218 218 + .get_track_ids(&playlist_id) 219 219 + .await 220 220 + .map_err(ErrorInternalServerError)?; 217 221 218 222 if track_ids.is_empty() { 219 219 - res.set_status(422); 220 220 - return Ok(()); 223 223 + return Ok(HttpResponse::UnprocessableEntity().finish()); 221 224 } 222 225 223 226 let mut paths = Vec::with_capacity(track_ids.len()); 224 227 for id in &track_ids { 225 225 - if let Some(track) = repo::track::find(ctx.pool.clone(), id).await? { 228 228 + if let Some(track) = repo::track::find(state.pool.clone(), id) 229 229 + .await 230 230 + .map_err(ErrorInternalServerError)? 231 231 + { 226 232 paths.push(track.path); 227 233 } 228 234 } 229 235 230 236 if paths.is_empty() { 231 231 - res.set_status(422); 232 232 - return Ok(()); 237 237 + return Ok(HttpResponse::UnprocessableEntity().finish()); 233 238 } 234 239 235 235 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 240 240 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 236 241 let first = &paths[0]; 237 242 let dir = { 238 243 let parts: Vec<_> = first.split('/').collect(); ··· 245 250 paths.len() as i32, 246 251 ); 247 252 rb::playlist::start(0, 0, 0); 248 248 - drop(player_mutex); 249 253 250 250 - res.set_status(204); 251 251 - Ok(()) 254 254 + Ok(HttpResponse::NoContent().finish()) 252 255 } 253 256 254 254 - // ── Folders ──────────────────────────────────────────────────────────────── 255 255 - 256 256 - pub async fn list_playlist_folders( 257 257 - ctx: &Context, 258 258 - _req: &Request, 259 259 - res: &mut Response, 260 260 - ) -> Result<(), Error> { 261 261 - let folders = ctx.playlist_store.list_folders().await?; 262 262 - res.json(&folders); 263 263 - Ok(()) 257 257 + pub async fn list_playlist_folders(state: web::Data<AppState>) -> HandlerResult { 258 258 + let folders = state 259 259 + .playlist_store 260 260 + .list_folders() 261 261 + .await 262 262 + .map_err(ErrorInternalServerError)?; 263 263 + Ok(HttpResponse::Ok().json(folders)) 264 264 } 265 265 266 266 pub async fn create_playlist_folder( 267 267 - ctx: &Context, 268 268 - req: &Request, 269 269 - res: &mut Response, 270 270 - ) -> Result<(), Error> { 271 271 - let body = match req.body.as_ref() { 272 272 - Some(b) => b, 273 273 - None => { 274 274 - res.set_status(400); 275 275 - return Ok(()); 276 276 - } 277 277 - }; 278 278 - let payload: CreateFolderBody = serde_json::from_str(body)?; 267 267 + state: web::Data<AppState>, 268 268 + body: web::Json<CreateFolderBody>, 269 269 + ) -> HandlerResult { 270 270 + let payload = body.into_inner(); 279 271 if payload.name.is_empty() { 280 280 - res.set_status(400); 281 281 - return Ok(()); 272 272 + return Ok(HttpResponse::BadRequest().finish()); 282 273 } 283 283 - let folder = ctx.playlist_store.create_folder(&payload.name).await?; 284 284 - res.set_status(201); 285 285 - res.json(&folder); 286 286 - Ok(()) 274 274 + let folder = state 275 275 + .playlist_store 276 276 + .create_folder(&payload.name) 277 277 + .await 278 278 + .map_err(ErrorInternalServerError)?; 279 279 + Ok(HttpResponse::Created().json(folder)) 287 280 } 288 281 289 282 pub async fn delete_playlist_folder( 290 290 - ctx: &Context, 291 291 - req: &Request, 292 292 - res: &mut Response, 293 293 - ) -> Result<(), Error> { 294 294 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 295 295 - ctx.playlist_store.delete_folder(id).await?; 296 296 - res.set_status(204); 297 297 - Ok(()) 283 283 + state: web::Data<AppState>, 284 284 + path: web::Path<String>, 285 285 + ) -> HandlerResult { 286 286 + let id = path.into_inner(); 287 287 + state 288 288 + .playlist_store 289 289 + .delete_folder(&id) 290 290 + .await 291 291 + .map_err(ErrorInternalServerError)?; 292 292 + Ok(HttpResponse::NoContent().finish()) 298 293 }

+19 -16

crates/server/src/handlers/search.rs

reviewed

··· 1 1 - use crate::http::{Context, Request, Response}; 2 2 - use anyhow::Error; 1 1 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 3 2 use rockbox_typesense::client::{search_albums, search_artists, search_tracks}; 4 4 - use serde::Serialize; 3 3 + use serde::{Deserialize, Serialize}; 4 4 + 5 5 + type HandlerResult = actix_web::Result<HttpResponse>; 6 6 + 7 7 + #[derive(Deserialize)] 8 8 + pub struct SearchQuery { 9 9 + q: Option<String>, 10 10 + } 5 11 6 12 #[derive(Default, Serialize)] 7 13 struct SearchResponse { ··· 10 16 artists: Vec<rockbox_typesense::types::Artist>, 11 17 } 12 18 13 13 - pub async fn search(_ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 14 14 - let term = req 15 15 - .query_params 16 16 - .get("q") 17 17 - .and_then(|t| t.as_str()) 18 18 - .unwrap_or_default(); 19 19 + pub async fn search(query: web::Query<SearchQuery>) -> HandlerResult { 20 20 + let term = query.q.as_deref().unwrap_or_default(); 19 21 20 22 let tracks = search_tracks(term) 21 21 - .await? 23 23 + .await 24 24 + .map_err(ErrorInternalServerError)? 22 25 .map(|r| r.hits.into_iter().map(|h| h.document).collect()) 23 26 .unwrap_or_default(); 24 27 let albums = search_albums(term) 25 25 - .await? 28 28 + .await 29 29 + .map_err(ErrorInternalServerError)? 26 30 .map(|r| r.hits.into_iter().map(|h| h.document).collect()) 27 31 .unwrap_or_default(); 28 32 let artists = search_artists(term) 29 29 - .await? 33 33 + .await 34 34 + .map_err(ErrorInternalServerError)? 30 35 .map(|r| r.hits.into_iter().map(|h| h.document).collect()) 31 36 .unwrap_or_default(); 32 37 33 33 - res.json(&SearchResponse { 38 38 + Ok(HttpResponse::Ok().json(SearchResponse { 34 39 tracks, 35 40 albums, 36 41 artists, 37 37 - }); 38 38 - 39 39 - Ok(()) 42 42 + })) 40 43 }

+24 -26

crates/server/src/handlers/settings.rs

reviewed

··· 1 1 - use crate::http::{Context, Request, Response}; 2 2 - use crate::PLAYER_MUTEX; 3 3 - use anyhow::Error; 1 1 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 4 2 use rockbox_sys as rb; 5 3 use rockbox_sys::types::user_settings::NewGlobalSettings; 6 4 7 7 - pub async fn get_global_settings( 8 8 - _ctx: &Context, 9 9 - _req: &Request, 10 10 - res: &mut Response, 11 11 - ) -> Result<(), Error> { 12 12 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 13 13 - let settings = rb::settings::get_global_settings(); 14 14 - res.json(&settings); 15 15 - drop(player_mutex); 16 16 - Ok(()) 5 5 + use crate::PLAYER_MUTEX; 6 6 + 7 7 + type HandlerResult = actix_web::Result<HttpResponse>; 8 8 + 9 9 + pub async fn get_global_settings() -> HandlerResult { 10 10 + let settings = web::block(|| { 11 11 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 12 12 + rb::settings::get_global_settings() 13 13 + }) 14 14 + .await 15 15 + .map_err(ErrorInternalServerError)?; 16 16 + Ok(HttpResponse::Ok().json(settings)) 17 17 } 18 18 19 19 - pub async fn update_global_settings( 20 20 - _ctx: &Context, 21 21 - req: &Request, 22 22 - res: &mut Response, 23 23 - ) -> Result<(), Error> { 24 24 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 25 25 - let body = req.body.as_ref().unwrap(); 26 26 - let settings: NewGlobalSettings = serde_json::from_str(body)?; 27 27 - rockbox_settings::load_settings(Some(settings))?; 28 28 - rockbox_settings::write_settings()?; 29 29 - res.set_status(204); 30 30 - drop(player_mutex); 31 31 - Ok(()) 19 19 + pub async fn update_global_settings(body: web::Json<NewGlobalSettings>) -> HandlerResult { 20 20 + let settings = body.into_inner(); 21 21 + web::block(move || { 22 22 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 23 23 + rockbox_settings::load_settings(Some(settings))?; 24 24 + rockbox_settings::write_settings() 25 25 + }) 26 26 + .await 27 27 + .map_err(ErrorInternalServerError)? 28 28 + .map_err(ErrorInternalServerError)?; 29 29 + Ok(HttpResponse::NoContent().finish()) 32 30 }

+114 -126

crates/server/src/handlers/smart_playlists.rs

reviewed

··· 1 1 - use crate::http::{Context, Request, Response}; 2 2 - use crate::PLAYER_MUTEX; 3 3 - use anyhow::Error; 1 1 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 4 2 use rockbox_library::repo; 5 3 use rockbox_playlists::rules::{Candidate, RuleCriteria}; 6 4 use rockbox_sys::{self as rb}; 7 5 use serde::Deserialize; 8 6 use std::collections::HashMap; 7 7 + 8 8 + use crate::{http::AppState, PLAYER_MUTEX}; 9 9 + 10 10 + type HandlerResult = actix_web::Result<HttpResponse>; 9 11 10 12 #[derive(Deserialize)] 11 11 - struct CreateSmartPlaylistBody { 13 13 + pub struct CreateSmartPlaylistBody { 12 14 name: String, 13 15 description: Option<String>, 14 16 image: Option<String>, ··· 17 19 } 18 20 19 21 #[derive(Deserialize)] 20 20 - struct UpdateSmartPlaylistBody { 22 22 + pub struct UpdateSmartPlaylistBody { 21 23 name: String, 22 24 description: Option<String>, 23 25 image: Option<String>, ··· 25 27 rules: RuleCriteria, 26 28 } 27 29 28 28 - pub async fn list_smart_playlists( 29 29 - ctx: &Context, 30 30 - _req: &Request, 31 31 - res: &mut Response, 32 32 - ) -> Result<(), Error> { 33 33 - let playlists = ctx.playlist_store.list_smart_playlists().await?; 34 34 - res.json(&playlists); 35 35 - Ok(()) 30 30 + pub async fn list_smart_playlists(state: web::Data<AppState>) -> HandlerResult { 31 31 + let playlists = state 32 32 + .playlist_store 33 33 + .list_smart_playlists() 34 34 + .await 35 35 + .map_err(ErrorInternalServerError)?; 36 36 + Ok(HttpResponse::Ok().json(playlists)) 36 37 } 37 38 38 39 pub async fn get_smart_playlist( 39 39 - ctx: &Context, 40 40 - req: &Request, 41 41 - res: &mut Response, 42 42 - ) -> Result<(), Error> { 43 43 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 44 44 - match ctx.playlist_store.get_smart_playlist(id).await? { 45 45 - Some(p) => res.json(&p), 46 46 - None => res.set_status(404), 40 40 + state: web::Data<AppState>, 41 41 + path: web::Path<String>, 42 42 + ) -> HandlerResult { 43 43 + let id = path.into_inner(); 44 44 + match state 45 45 + .playlist_store 46 46 + .get_smart_playlist(&id) 47 47 + .await 48 48 + .map_err(ErrorInternalServerError)? 49 49 + { 50 50 + Some(p) => Ok(HttpResponse::Ok().json(p)), 51 51 + None => Ok(HttpResponse::NotFound().finish()), 47 52 } 48 48 - Ok(()) 49 53 } 50 54 51 55 pub async fn create_smart_playlist( 52 52 - ctx: &Context, 53 53 - req: &Request, 54 54 - res: &mut Response, 55 55 - ) -> Result<(), Error> { 56 56 - let body = match req.body.as_ref() { 57 57 - Some(b) => b, 58 58 - None => { 59 59 - res.set_status(400); 60 60 - return Ok(()); 61 61 - } 62 62 - }; 63 63 - let payload: CreateSmartPlaylistBody = serde_json::from_str(body)?; 56 56 + state: web::Data<AppState>, 57 57 + body: web::Json<CreateSmartPlaylistBody>, 58 58 + ) -> HandlerResult { 59 59 + let payload = body.into_inner(); 64 60 if payload.name.is_empty() { 65 65 - res.set_status(400); 66 66 - return Ok(()); 61 61 + return Ok(HttpResponse::BadRequest().finish()); 67 62 } 68 68 - let playlist = ctx 63 63 + let playlist = state 69 64 .playlist_store 70 65 .create_smart_playlist( 71 66 &payload.name, ··· 74 69 payload.folder_id.as_deref(), 75 70 &payload.rules, 76 71 ) 77 77 - .await?; 78 78 - res.set_status(201); 79 79 - res.json(&playlist); 80 80 - Ok(()) 72 72 + .await 73 73 + .map_err(ErrorInternalServerError)?; 74 74 + Ok(HttpResponse::Created().json(playlist)) 81 75 } 82 76 83 77 pub async fn update_smart_playlist( 84 84 - ctx: &Context, 85 85 - req: &Request, 86 86 - res: &mut Response, 87 87 - ) -> Result<(), Error> { 88 88 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 89 89 - let body = match req.body.as_ref() { 90 90 - Some(b) => b, 91 91 - None => { 92 92 - res.set_status(400); 93 93 - return Ok(()); 94 94 - } 95 95 - }; 96 96 - let payload: UpdateSmartPlaylistBody = serde_json::from_str(body)?; 97 97 - match ctx 78 78 + state: web::Data<AppState>, 79 79 + path: web::Path<String>, 80 80 + body: web::Json<UpdateSmartPlaylistBody>, 81 81 + ) -> HandlerResult { 82 82 + let id = path.into_inner(); 83 83 + let payload = body.into_inner(); 84 84 + match state 98 85 .playlist_store 99 86 .update_smart_playlist( 100 100 - id, 87 87 + &id, 101 88 &payload.name, 102 89 payload.description.as_deref(), 103 90 payload.image.as_deref(), ··· 106 93 ) 107 94 .await 108 95 { 109 109 - Ok(()) => res.set_status(204), 110 110 - Err(_) => res.set_status(404), 96 96 + Ok(()) => Ok(HttpResponse::NoContent().finish()), 97 97 + Err(_) => Ok(HttpResponse::NotFound().finish()), 111 98 } 112 112 - Ok(()) 113 99 } 114 100 115 101 pub async fn delete_smart_playlist( 116 116 - ctx: &Context, 117 117 - req: &Request, 118 118 - res: &mut Response, 119 119 - ) -> Result<(), Error> { 120 120 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 121 121 - let deleted = ctx.playlist_store.delete_smart_playlist(id).await?; 102 102 + state: web::Data<AppState>, 103 103 + path: web::Path<String>, 104 104 + ) -> HandlerResult { 105 105 + let id = path.into_inner(); 106 106 + let deleted = state 107 107 + .playlist_store 108 108 + .delete_smart_playlist(&id) 109 109 + .await 110 110 + .map_err(ErrorInternalServerError)?; 122 111 if deleted { 123 123 - res.set_status(204); 112 112 + Ok(HttpResponse::NoContent().finish()) 124 113 } else { 125 125 - res.set_status(404); 114 114 + Ok(HttpResponse::NotFound().finish()) 126 115 } 127 127 - Ok(()) 128 116 } 129 117 130 118 async fn resolve_smart_playlist_tracks( 131 131 - ctx: &Context, 119 119 + state: &AppState, 132 120 id: &str, 133 133 - ) -> Result<Option<(RuleCriteria, Vec<rockbox_library::entity::track::Track>)>, Error> { 134 134 - let criteria = match ctx.playlist_store.get_smart_playlist(id).await? { 121 121 + ) -> Result<Option<(RuleCriteria, Vec<rockbox_library::entity::track::Track>)>, anyhow::Error> { 122 122 + let criteria = match state.playlist_store.get_smart_playlist(id).await? { 135 123 Some(p) => p.rules, 136 124 None => return Ok(None), 137 125 }; 138 126 139 139 - let all_tracks = repo::track::all(ctx.pool.clone()).await?; 127 127 + let all_tracks = repo::track::all(state.pool.clone()).await?; 140 128 141 141 - let stats_map: HashMap<String, rockbox_playlists::TrackStats> = ctx 129 129 + let stats_map: HashMap<String, rockbox_playlists::TrackStats> = state 142 130 .playlist_store 143 131 .get_all_track_stats() 144 132 .await? ··· 147 135 .collect(); 148 136 149 137 let liked_ids: std::collections::HashSet<String> = 150 150 - repo::favourites::all_tracks(ctx.pool.clone()) 138 138 + repo::favourites::all_tracks(state.pool.clone()) 151 139 .await? 152 140 .into_iter() 153 141 .map(|t| t.id) ··· 177 165 .collect(); 178 166 179 167 let resolved = rockbox_playlists::rules::resolve(&criteria, candidates); 180 180 - 181 168 let resolved_ids: Vec<&str> = resolved.iter().map(|c| c.id.as_str()).collect(); 182 169 let track_map: HashMap<&str, &rockbox_library::entity::track::Track> = 183 170 all_tracks.iter().map(|t| (t.id.as_str(), t)).collect(); ··· 191 178 } 192 179 193 180 pub async fn get_smart_playlist_tracks( 194 194 - ctx: &Context, 195 195 - req: &Request, 196 196 - res: &mut Response, 197 197 - ) -> Result<(), Error> { 198 198 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 199 199 - match resolve_smart_playlist_tracks(ctx, id).await? { 200 200 - Some((_, tracks)) => res.json(&tracks), 201 201 - None => res.set_status(404), 181 181 + state: web::Data<AppState>, 182 182 + path: web::Path<String>, 183 183 + ) -> HandlerResult { 184 184 + let id = path.into_inner(); 185 185 + match resolve_smart_playlist_tracks(&state, &id) 186 186 + .await 187 187 + .map_err(ErrorInternalServerError)? 188 188 + { 189 189 + Some((_, tracks)) => Ok(HttpResponse::Ok().json(tracks)), 190 190 + None => Ok(HttpResponse::NotFound().finish()), 202 191 } 203 203 - Ok(()) 204 192 } 205 193 206 194 pub async fn play_smart_playlist( 207 207 - ctx: &Context, 208 208 - req: &Request, 209 209 - res: &mut Response, 210 210 - ) -> Result<(), Error> { 211 211 - let id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 212 212 - let tracks = match resolve_smart_playlist_tracks(ctx, id).await? { 195 195 + state: web::Data<AppState>, 196 196 + path: web::Path<String>, 197 197 + ) -> HandlerResult { 198 198 + let id = path.into_inner(); 199 199 + let tracks = match resolve_smart_playlist_tracks(&state, &id) 200 200 + .await 201 201 + .map_err(ErrorInternalServerError)? 202 202 + { 213 203 Some((_, t)) => t, 214 214 - None => { 215 215 - res.set_status(404); 216 216 - return Ok(()); 217 217 - } 204 204 + None => return Ok(HttpResponse::NotFound().finish()), 218 205 }; 219 206 220 207 if tracks.is_empty() { 221 221 - res.set_status(422); 222 222 - return Ok(()); 208 208 + return Ok(HttpResponse::UnprocessableEntity().finish()); 223 209 } 224 210 225 211 let paths: Vec<String> = tracks.iter().map(|t| t.path.clone()).collect(); 226 226 - let player_mutex = PLAYER_MUTEX.lock().unwrap(); 212 212 + let _player_mutex = PLAYER_MUTEX.lock().unwrap(); 227 213 let first = &paths[0]; 228 214 let dir = { 229 215 let parts: Vec<_> = first.split('/').collect(); ··· 236 222 paths.len() as i32, 237 223 ); 238 224 rb::playlist::start(0, 0, 0); 239 239 - drop(player_mutex); 240 225 241 241 - res.set_status(204); 242 242 - Ok(()) 226 226 + Ok(HttpResponse::NoContent().finish()) 243 227 } 244 228 245 229 pub async fn record_track_played( 246 246 - ctx: &Context, 247 247 - req: &Request, 248 248 - res: &mut Response, 249 249 - ) -> Result<(), Error> { 250 250 - let track_id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 251 251 - ctx.playlist_store.record_play(track_id).await?; 252 252 - res.set_status(204); 253 253 - Ok(()) 230 230 + state: web::Data<AppState>, 231 231 + path: web::Path<String>, 232 232 + ) -> HandlerResult { 233 233 + let track_id = path.into_inner(); 234 234 + state 235 235 + .playlist_store 236 236 + .record_play(&track_id) 237 237 + .await 238 238 + .map_err(ErrorInternalServerError)?; 239 239 + Ok(HttpResponse::NoContent().finish()) 254 240 } 255 241 256 242 pub async fn record_track_skipped( 257 257 - ctx: &Context, 258 258 - req: &Request, 259 259 - res: &mut Response, 260 260 - ) -> Result<(), Error> { 261 261 - let track_id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 262 262 - ctx.playlist_store.record_skip(track_id).await?; 263 263 - res.set_status(204); 264 264 - Ok(()) 243 243 + state: web::Data<AppState>, 244 244 + path: web::Path<String>, 245 245 + ) -> HandlerResult { 246 246 + let track_id = path.into_inner(); 247 247 + state 248 248 + .playlist_store 249 249 + .record_skip(&track_id) 250 250 + .await 251 251 + .map_err(ErrorInternalServerError)?; 252 252 + Ok(HttpResponse::NoContent().finish()) 265 253 } 266 254 267 267 - pub async fn get_track_stats( 268 268 - ctx: &Context, 269 269 - req: &Request, 270 270 - res: &mut Response, 271 271 - ) -> Result<(), Error> { 272 272 - let track_id = req.params.first().map(|s| s.as_str()).unwrap_or(""); 273 273 - match ctx.playlist_store.get_track_stats(track_id).await? { 274 274 - Some(s) => res.json(&s), 275 275 - None => res.set_status(404), 255 255 + pub async fn get_track_stats(state: web::Data<AppState>, path: web::Path<String>) -> HandlerResult { 256 256 + let track_id = path.into_inner(); 257 257 + match state 258 258 + .playlist_store 259 259 + .get_track_stats(&track_id) 260 260 + .await 261 261 + .map_err(ErrorInternalServerError)? 262 262 + { 263 263 + Some(s) => Ok(HttpResponse::Ok().json(s)), 264 264 + None => Ok(HttpResponse::NotFound().finish()), 276 265 } 277 277 - Ok(()) 278 266 }

+64 -44

crates/server/src/handlers/system.rs

reviewed

··· 1 1 use std::env; 2 2 3 3 - use crate::http::{Context, Request, Response}; 4 4 - use anyhow::Error; 3 3 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 5 4 use rockbox_graphql::{simplebroker::SimpleBroker, types::ScanCompleted}; 6 5 use rockbox_library::{artists::update_metadata, audio_scan::scan_audio_files, repo}; 7 6 use rockbox_sys as rb; 8 8 - use rockbox_typesense::client::*; 9 9 - use rockbox_typesense::types::*; 7 7 + use rockbox_typesense::{client::*, types::*}; 8 8 + use serde::Deserialize; 10 9 11 11 - pub async fn get_status(_ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 10 10 + use crate::http::AppState; 11 11 + 12 12 + type HandlerResult = actix_web::Result<HttpResponse>; 13 13 + 14 14 + pub async fn get_status() -> HandlerResult { 12 15 let status = rb::system::get_global_status(); 13 13 - res.json(&status); 14 14 - Ok(()) 16 16 + Ok(HttpResponse::Ok().json(status)) 15 17 } 16 18 17 17 - pub async fn get_rockbox_version( 18 18 - _ctx: &Context, 19 19 - _req: &Request, 20 20 - res: &mut Response, 21 21 - ) -> Result<(), Error> { 19 19 + pub async fn get_rockbox_version() -> HandlerResult { 22 20 let version = rb::system::get_rockbox_version(); 23 23 - res.json(&version); 24 24 - Ok(()) 21 21 + Ok(HttpResponse::Ok().json(version)) 25 22 } 26 23 27 27 - pub async fn scan_library(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 28 28 - let home = env::var("HOME")?; 24 24 + #[derive(Deserialize)] 25 25 + pub struct ScanQuery { 26 26 + path: Option<String>, 27 27 + rebuild_index: Option<String>, 28 28 + } 29 29 + 30 30 + pub async fn scan_library( 31 31 + state: web::Data<AppState>, 32 32 + query: web::Query<ScanQuery>, 33 33 + ) -> HandlerResult { 34 34 + let home = env::var("HOME").map_err(ErrorInternalServerError)?; 29 35 let music_library = format!("{}/Music", home); 30 36 31 31 - let path = match req.query_params.get("path") { 32 32 - Some(path) => path.as_str().unwrap_or(&music_library), 33 33 - None => &music_library, 34 34 - }; 37 37 + let path = query.path.clone().unwrap_or_else(|| music_library.clone()); 35 38 36 36 - scan_audio_files(ctx.pool.clone(), path.into()).await?; 39 39 + scan_audio_files(state.pool.clone(), path.clone().into()) 40 40 + .await 41 41 + .map_err(ErrorInternalServerError)?; 37 42 38 38 - let rebuild_index = match req.query_params.get("rebuild_index") { 39 39 - Some(rebuild_index) => { 40 40 - let rebuild_index = rebuild_index.as_str().unwrap_or("false"); 41 41 - rebuild_index == "true" || rebuild_index == "1" 42 42 - } 43 43 - None => false, 44 44 - }; 43 43 + let rebuild_index = query 44 44 + .rebuild_index 45 45 + .as_deref() 46 46 + .map(|s| s == "true" || s == "1") 47 47 + .unwrap_or(false); 45 48 46 49 if path != music_library { 47 50 SimpleBroker::publish(ScanCompleted); 48 48 - res.text("0"); 49 49 - return Ok(()); 51 51 + return Ok(HttpResponse::Ok().body("0")); 50 52 } 51 53 52 52 - update_metadata(ctx.pool.clone()).await?; 54 54 + update_metadata(state.pool.clone()) 55 55 + .await 56 56 + .map_err(ErrorInternalServerError)?; 53 57 54 58 if !rebuild_index { 55 59 SimpleBroker::publish(ScanCompleted); 56 56 - res.text("0"); 57 57 - return Ok(()); 60 60 + return Ok(HttpResponse::Ok().body("0")); 58 61 } 59 62 60 60 - let tracks = repo::track::all(ctx.pool.clone()).await?; 61 61 - let albums = repo::album::all(ctx.pool.clone()).await?; 62 62 - let artists = repo::artist::all(ctx.pool.clone()).await?; 63 63 + let tracks = repo::track::all(state.pool.clone()) 64 64 + .await 65 65 + .map_err(ErrorInternalServerError)?; 66 66 + let albums = repo::album::all(state.pool.clone()) 67 67 + .await 68 68 + .map_err(ErrorInternalServerError)?; 69 69 + let artists = repo::artist::all(state.pool.clone()) 70 70 + .await 71 71 + .map_err(ErrorInternalServerError)?; 63 72 64 64 - create_tracks_collection().await?; 65 65 - create_albums_collection().await?; 66 66 - create_artists_collection().await?; 73 73 + create_tracks_collection() 74 74 + .await 75 75 + .map_err(ErrorInternalServerError)?; 76 76 + create_albums_collection() 77 77 + .await 78 78 + .map_err(ErrorInternalServerError)?; 79 79 + create_artists_collection() 80 80 + .await 81 81 + .map_err(ErrorInternalServerError)?; 67 82 68 68 - insert_tracks(tracks.into_iter().map(Track::from).collect()).await?; 69 69 - insert_artists(artists.into_iter().map(Artist::from).collect()).await?; 70 70 - insert_albums(albums.into_iter().map(Album::from).collect()).await?; 83 83 + insert_tracks(tracks.into_iter().map(Track::from).collect()) 84 84 + .await 85 85 + .map_err(ErrorInternalServerError)?; 86 86 + insert_artists(artists.into_iter().map(Artist::from).collect()) 87 87 + .await 88 88 + .map_err(ErrorInternalServerError)?; 89 89 + insert_albums(albums.into_iter().map(Album::from).collect()) 90 90 + .await 91 91 + .map_err(ErrorInternalServerError)?; 71 92 72 93 SimpleBroker::publish(ScanCompleted); 73 73 - res.text("0"); 74 74 - Ok(()) 94 94 + Ok(HttpResponse::Ok().body("0")) 75 95 }

+27 -32

crates/server/src/handlers/tracks.rs

reviewed

··· 1 1 - use anyhow::Error; 1 1 + use actix_web::{error::ErrorInternalServerError, web, HttpResponse}; 2 2 use rockbox_library::{audio_scan, repo}; 3 3 use serde::Deserialize; 4 4 5 5 - use crate::http::{Context, Request, Response}; 5 5 + use crate::http::AppState; 6 6 7 7 - pub async fn get_tracks(ctx: &Context, _req: &Request, res: &mut Response) -> Result<(), Error> { 8 8 - let tracks = repo::track::all(ctx.pool.clone()).await?; 9 9 - res.json(&tracks); 10 10 - Ok(()) 7 7 + type HandlerResult = actix_web::Result<HttpResponse>; 8 8 + 9 9 + pub async fn get_tracks(state: web::Data<AppState>) -> HandlerResult { 10 10 + let tracks = repo::track::all(state.pool.clone()) 11 11 + .await 12 12 + .map_err(ErrorInternalServerError)?; 13 13 + Ok(HttpResponse::Ok().json(tracks)) 11 14 } 12 15 13 13 - pub async fn get_track(ctx: &Context, req: &Request, res: &mut Response) -> Result<(), Error> { 14 14 - let track = repo::track::find(ctx.pool.clone(), &req.params[0]).await?; 15 15 - res.json(&track); 16 16 - Ok(()) 16 16 + pub async fn get_track(state: web::Data<AppState>, path: web::Path<String>) -> HandlerResult { 17 17 + let track = repo::track::find(state.pool.clone(), &path.into_inner()) 18 18 + .await 19 19 + .map_err(ErrorInternalServerError)?; 20 20 + Ok(HttpResponse::Ok().json(track)) 17 21 } 18 22 19 23 #[derive(Deserialize)] 20 20 - struct StreamMetadataBody { 24 24 + pub struct StreamMetadataBody { 21 25 url: String, 22 26 title: String, 23 27 artist: String, ··· 26 30 } 27 31 28 32 pub async fn save_stream_track_metadata( 29 29 - ctx: &Context, 30 30 - req: &Request, 31 31 - res: &mut Response, 32 32 - ) -> Result<(), Error> { 33 33 - let body = match req.body.as_ref() { 34 34 - Some(b) => b, 35 35 - None => { 36 36 - res.set_status(400); 37 37 - return Ok(()); 38 38 - } 39 39 - }; 40 40 - let params: StreamMetadataBody = serde_json::from_str(body)?; 33 33 + state: web::Data<AppState>, 34 34 + body: web::Json<StreamMetadataBody>, 35 35 + ) -> HandlerResult { 41 36 audio_scan::save_stream_metadata( 42 42 - ctx.pool.clone(), 43 43 - &params.url, 44 44 - &params.title, 45 45 - &params.artist, 46 46 - &params.album, 47 47 - params.duration_ms, 37 37 + state.pool.clone(), 38 38 + &body.url, 39 39 + &body.title, 40 40 + &body.artist, 41 41 + &body.album, 42 42 + body.duration_ms, 48 43 ) 49 49 - .await?; 50 50 - res.set_status(204); 51 51 - Ok(()) 44 44 + .await 45 45 + .map_err(ErrorInternalServerError)?; 46 46 + Ok(HttpResponse::NoContent().finish()) 52 47 }

+3 -543

crates/server/src/http.rs

reviewed

··· 1 1 - use anyhow::Error; 2 1 use rockbox_library::entity::track::Track; 3 2 use rockbox_playlists::PlaylistStore; 4 4 - use rockbox_sys::{ 5 5 - self as rb, 6 6 - types::{mp3_entry::Mp3Entry, tree::Entry}, 7 7 - }; 3 3 + use rockbox_sys::types::{mp3_entry::Mp3Entry, tree::Entry}; 8 4 use rockbox_traits::Player; 9 5 use rockbox_types::device::Device; 10 10 - use serde::Serialize; 11 11 - use serde_json::Value; 12 6 use sqlx::Sqlite; 13 7 use std::{ 14 8 collections::HashMap, 15 15 - io::{BufRead, BufReader, Read, Write}, 16 16 - net::{TcpListener, TcpStream}, 17 9 sync::{Arc, Mutex}, 18 18 - thread, 19 19 - time::Duration, 20 10 }; 21 21 - use threadpool::ThreadPool; 22 22 - use tracing::{debug, error}; 23 11 24 24 - use crate::{ 25 25 - kv::{build_tracks_kv, KV}, 26 26 - player_events::listen_for_playback_changes, 27 27 - scan::{ 28 28 - scan_airplay_devices, scan_chromecast_devices, scan_snapcast_servers, 29 29 - scan_squeezelite_clients, scan_upnp_devices, virtual_devices, 30 30 - }, 31 31 - }; 12 12 + use crate::kv::KV; 32 13 33 33 - type Handler = fn(&Context, &Request, &mut Response) -> Result<(), Error>; 34 34 - 35 35 - pub struct Context { 14 14 + pub struct AppState { 36 15 pub pool: sqlx::Pool<Sqlite>, 37 37 - pub rt: Arc<tokio::runtime::Runtime>, 38 16 pub fs_cache: Arc<tokio::sync::Mutex<HashMap<String, Vec<Entry>>>>, 39 17 pub metadata_cache: Arc<tokio::sync::Mutex<HashMap<String, Mp3Entry>>>, 40 18 pub devices: Arc<Mutex<Vec<Device>>>, ··· 43 21 pub kv: Arc<Mutex<KV<Track>>>, 44 22 pub playlist_store: PlaylistStore, 45 23 } 46 46 - 47 47 - #[derive(Debug)] 48 48 - pub struct Request { 49 49 - pub method: String, 50 50 - pub params: Vec<String>, 51 51 - pub query_params: Value, 52 52 - pub body: Option<String>, 53 53 - } 54 54 - 55 55 - #[derive(Debug)] 56 56 - pub struct Response { 57 57 - body: String, 58 58 - status_code: u16, 59 59 - headers: HashMap<String, String>, 60 60 - } 61 61 - 62 62 - impl Response { 63 63 - pub fn new() -> Self { 64 64 - Response { 65 65 - body: String::new(), 66 66 - status_code: 200, 67 67 - headers: HashMap::new(), 68 68 - } 69 69 - } 70 70 - 71 71 - pub fn json<T: Serialize>(&mut self, value: &T) { 72 72 - let json_value = serde_json::to_value(value).unwrap(); 73 73 - self.add_header("Content-Type", "application/json"); 74 74 - self.body = serde_json::to_string(&json_value).unwrap(); 75 75 - } 76 76 - 77 77 - pub fn text(&mut self, text: &str) { 78 78 - self.add_header("Content-Type", "text/plain"); 79 79 - self.body = text.to_string(); 80 80 - } 81 81 - 82 82 - pub fn set_body(&mut self, body: &str) { 83 83 - self.body = body.to_string(); 84 84 - } 85 85 - 86 86 - pub fn set_status(&mut self, status: u16) { 87 87 - self.status_code = status; 88 88 - } 89 89 - 90 90 - pub fn add_header(&mut self, key: &str, value: &str) { 91 91 - self.headers.insert(key.to_string(), value.to_string()); 92 92 - } 93 93 - 94 94 - pub fn send(self, stream: &mut TcpStream) { 95 95 - let status_line = format!("HTTP/1.1 {} OK\r\n", self.status_code); 96 96 - let mut response = status_line; 97 97 - 98 98 - for (key, value) in self.headers { 99 99 - response.push_str(&format!("{}: {}\r\n", key, value)); 100 100 - } 101 101 - response.push_str(&format!("Content-Length: {}\r\n", self.body.len())); 102 102 - response.push_str("\r\n"); 103 103 - response.push_str(&self.body); 104 104 - 105 105 - if let Err(e) = stream.write_all(response.as_bytes()) { 106 106 - tracing::debug!("http: write error: {e}"); 107 107 - return; 108 108 - } 109 109 - if let Err(e) = stream.flush() { 110 110 - tracing::debug!("http: flush error: {e}"); 111 111 - } 112 112 - } 113 113 - } 114 114 - 115 115 - fn split_path_and_query(path: &str) -> (&str, Option<&str>) { 116 116 - match path.find('?') { 117 117 - Some(pos) => (&path[..pos], Some(&path[pos + 1..])), 118 118 - None => (path, None), 119 119 - } 120 120 - } 121 121 - 122 122 - #[derive(Clone)] 123 123 - struct Router { 124 124 - routes: HashMap<String, HashMap<String, Handler>>, // method -> path -> handler 125 125 - } 126 126 - 127 127 - impl Router { 128 128 - pub fn new() -> Self { 129 129 - Router { 130 130 - routes: HashMap::new(), 131 131 - } 132 132 - } 133 133 - 134 134 - // Define the `get` method for routing GET requests 135 135 - fn get(&mut self, path: &str, handler: Handler) { 136 136 - self.add_route("GET", path, handler); 137 137 - } 138 138 - 139 139 - // Define the `post` method for routing POST requests 140 140 - fn post(&mut self, path: &str, handler: Handler) { 141 141 - self.add_route("POST", path, handler); 142 142 - } 143 143 - 144 144 - // Define the `put` method for routing PUT requests 145 145 - fn put(&mut self, path: &str, handler: Handler) { 146 146 - self.add_route("PUT", path, handler); 147 147 - } 148 148 - 149 149 - fn delete(&mut self, path: &str, handler: Handler) { 150 150 - self.add_route("DELETE", path, handler); 151 151 - } 152 152 - 153 153 - // Add route to the routing table 154 154 - pub fn add_route(&mut self, method: &str, path: &str, handler: Handler) { 155 155 - self.routes 156 156 - .entry(method.to_string()) 157 157 - .or_insert_with(HashMap::new) 158 158 - .insert(path.to_string(), handler); 159 159 - } 160 160 - 161 161 - // Match the method and path to find the corresponding handler 162 162 - pub fn route(&self, method: &str, path: &str) -> Option<(&Handler, Vec<String>)> { 163 163 - let (path_without_query, _) = split_path_and_query(path); 164 164 - if let Some(routes) = self.routes.get(method) { 165 165 - for (route_path, handler) in routes { 166 166 - let mut params = Vec::new(); 167 167 - if self.match_route(route_path, path_without_query, &mut params) { 168 168 - return Some((handler, params)); 169 169 - } 170 170 - } 171 171 - } 172 172 - None 173 173 - } 174 174 - 175 175 - // Simple route matching to support dynamic parameters 176 176 - pub fn match_route( 177 177 - &self, 178 178 - route_path: &str, 179 179 - request_path: &str, 180 180 - params: &mut Vec<String>, 181 181 - ) -> bool { 182 182 - let route_parts: Vec<&str> = route_path.split('/').collect(); 183 183 - let request_parts: Vec<&str> = request_path.split('/').collect(); 184 184 - 185 185 - if route_parts.len() > request_parts.len() { 186 186 - return false; 187 187 - } 188 188 - 189 189 - for (route_part, request_part) in route_parts.iter().zip(request_parts.iter()) { 190 190 - if route_part.starts_with(":") { 191 191 - params.push(request_part.to_string()); // Capture the parameter 192 192 - } else if route_part != request_part { 193 193 - return false; // Paths don't match 194 194 - } 195 195 - } 196 196 - 197 197 - // Ensure that the remaining parts of the request path are empty if the route path is shorter 198 198 - if route_parts.len() < request_parts.len() { 199 199 - for remaining_part in &request_parts[route_parts.len()..] { 200 200 - if !remaining_part.is_empty() { 201 201 - return false; 202 202 - } 203 203 - } 204 204 - } 205 205 - 206 206 - true 207 207 - } 208 208 - } 209 209 - 210 210 - #[derive(Clone)] 211 211 - pub struct RockboxHttpServer { 212 212 - router: Router, 213 213 - } 214 214 - 215 215 - impl RockboxHttpServer { 216 216 - pub fn new() -> Self { 217 217 - RockboxHttpServer { 218 218 - router: Router::new(), 219 219 - } 220 220 - } 221 221 - 222 222 - // Define the `get` method for routing GET requests 223 223 - pub fn get(&mut self, path: &str, handler: Handler) { 224 224 - self.router.get(path, handler); 225 225 - } 226 226 - 227 227 - // Define the `post` method for routing POST requests 228 228 - pub fn post(&mut self, path: &str, handler: Handler) { 229 229 - self.router.post(path, handler); 230 230 - } 231 231 - 232 232 - // Define the `put` method for routing PUT requests 233 233 - pub fn put(&mut self, path: &str, handler: Handler) { 234 234 - self.router.put(path, handler); 235 235 - } 236 236 - 237 237 - // Define the `delete` method for routing DELETE requests 238 238 - pub fn delete(&mut self, path: &str, handler: Handler) { 239 239 - self.router.delete(path, handler); 240 240 - } 241 241 - 242 242 - // Start listening and handling incoming requests 243 243 - pub fn listen(&mut self) -> Result<(), Error> { 244 244 - let port = std::env::var("ROCKBOX_TCP_PORT").unwrap_or_else(|_| "6063".to_string()); 245 245 - let addr = format!("0.0.0.0:{}", port); 246 246 - let listener = TcpListener::bind(&addr)?; 247 247 - listener.set_nonblocking(true)?; 248 248 - 249 249 - let pool = ThreadPool::new(4); 250 250 - let active_connections = Arc::new(Mutex::new(0)); 251 251 - let rt = Arc::new(tokio::runtime::Runtime::new()?); 252 252 - let db_pool = rt.block_on(rockbox_library::create_connection_pool())?; 253 253 - let fs_cache = Arc::new(tokio::sync::Mutex::new(HashMap::new())); 254 254 - let metadata_cache = Arc::new(tokio::sync::Mutex::new(HashMap::new())); 255 255 - // Seed device list with always-present virtual outputs. 256 256 - let devices = Arc::new(Mutex::new(virtual_devices())); 257 257 - 258 258 - // Determine which device is currently active from settings.toml. 259 259 - let current_device = { 260 260 - let active = rockbox_settings::read_settings().ok().and_then(|s| { 261 261 - let output = s.audio_output.as_deref().unwrap_or("builtin"); 262 262 - let mut device = match output { 263 263 - "builtin" | "fifo" => { 264 264 - virtual_devices().into_iter().find(|d| d.service == output) 265 265 - } 266 266 - "airplay" => { 267 267 - let host = s.airplay_host.clone().unwrap_or_default(); 268 268 - Some(Device { 269 269 - id: format!("airplay-{}", host), 270 270 - name: if host.is_empty() { 271 271 - "AirPlay".to_string() 272 272 - } else { 273 273 - format!("AirPlay ({})", host) 274 274 - }, 275 275 - host: host.clone(), 276 276 - ip: host, 277 277 - port: s.airplay_port.unwrap_or(5000), 278 278 - service: "airplay".to_string(), 279 279 - app: "AirPlay".to_string(), 280 280 - ..Default::default() 281 281 - }) 282 282 - } 283 283 - "squeezelite" => Some(Device { 284 284 - id: "squeezelite".to_string(), 285 285 - name: "Squeezelite".to_string(), 286 286 - host: "localhost".to_string(), 287 287 - ip: "127.0.0.1".to_string(), 288 288 - port: s.squeezelite_port.unwrap_or(3483), 289 289 - service: "squeezelite".to_string(), 290 290 - app: "squeezelite".to_string(), 291 291 - ..Default::default() 292 292 - }), 293 293 - "upnp" => { 294 294 - let url = s.upnp_renderer_url.clone().unwrap_or_default(); 295 295 - Some(Device { 296 296 - id: format!( 297 297 - "upnp-{:.8}", 298 298 - format!("{:x}", md5::compute(url.as_bytes())) 299 299 - ), 300 300 - name: "UPnP/DLNA".to_string(), 301 301 - host: "localhost".to_string(), 302 302 - ip: "127.0.0.1".to_string(), 303 303 - port: 0, 304 304 - service: "upnp".to_string(), 305 305 - app: "upnp".to_string(), 306 306 - base_url: Some(url), 307 307 - ..Default::default() 308 308 - }) 309 309 - } 310 310 - "chromecast" => { 311 311 - let host = s.chromecast_host.clone().unwrap_or_default(); 312 312 - Some(Device { 313 313 - id: format!("chromecast-{}", host), 314 314 - name: if host.is_empty() { 315 315 - "Chromecast".to_string() 316 316 - } else { 317 317 - format!("Chromecast ({})", host) 318 318 - }, 319 319 - host: host.clone(), 320 320 - ip: host, 321 321 - port: s.chromecast_port.unwrap_or(8009), 322 322 - service: "chromecast".to_string(), 323 323 - app: "Chromecast".to_string(), 324 324 - is_cast_device: true, 325 325 - ..Default::default() 326 326 - }) 327 327 - } 328 328 - "snapcast_tcp" => { 329 329 - let host = s.snapcast_tcp_host.clone().unwrap_or_default(); 330 330 - Some(Device { 331 331 - id: format!("snapcast-{}", host), 332 332 - name: if host.is_empty() { 333 333 - "Snapcast".to_string() 334 334 - } else { 335 335 - format!("Snapcast ({})", host) 336 336 - }, 337 337 - host: host.clone(), 338 338 - ip: host, 339 339 - port: s.snapcast_tcp_port.unwrap_or(4953), 340 340 - service: "snapcast".to_string(), 341 341 - app: "Snapcast".to_string(), 342 342 - is_cast_device: true, 343 343 - ..Default::default() 344 344 - }) 345 345 - } 346 346 - _ => virtual_devices() 347 347 - .into_iter() 348 348 - .find(|d| d.service == "builtin"), 349 349 - }; 350 350 - if let Some(ref mut d) = device { 351 351 - d.is_current_device = true; 352 352 - } 353 353 - device 354 354 - }); 355 355 - Arc::new(Mutex::new(active)) 356 356 - }; 357 357 - 358 358 - let player = Arc::new(Mutex::new(None)); 359 359 - let kv = Arc::new(Mutex::new(rt.block_on(build_tracks_kv(db_pool.clone()))?)); 360 360 - 361 361 - let playlist_store = PlaylistStore::new(db_pool.clone()); 362 362 - rt.block_on(playlist_store.seed()) 363 363 - .expect("Failed to seed playlist store"); 364 364 - 365 365 - // Start scanning for devices 366 366 - scan_chromecast_devices(devices.clone()); 367 367 - scan_upnp_devices(devices.clone()); 368 368 - scan_airplay_devices(devices.clone()); 369 369 - scan_snapcast_servers(devices.clone()); 370 370 - scan_squeezelite_clients(devices.clone()); 371 371 - listen_for_playback_changes(player.clone(), db_pool.clone()); 372 372 - 373 373 - loop { 374 374 - match listener.accept() { 375 375 - Ok((stream, _)) => { 376 376 - // The listener is non-blocking so the accept loop can check 377 377 - // active connections; reset the accepted stream to blocking 378 378 - // so handler-thread reads/writes don't get WouldBlock. 379 379 - if let Err(e) = stream.set_nonblocking(false) { 380 380 - tracing::warn!("http: set_nonblocking(false) failed: {e}"); 381 381 - continue; 382 382 - } 383 383 - let db_pool = db_pool.clone(); 384 384 - let active_connections = Arc::clone(&active_connections); 385 385 - { 386 386 - let mut active_connections = active_connections.lock().unwrap(); 387 387 - *active_connections += 1; 388 388 - } 389 389 - let mut cloned_self = self.clone(); 390 390 - let cloned_rt = rt.clone(); 391 391 - let cloned_fs_cache = fs_cache.clone(); 392 392 - let cloned_metadata_cache = metadata_cache.clone(); 393 393 - let cloned_devices = devices.clone(); 394 394 - let cloned_current_device = current_device.clone(); 395 395 - let cloned_player = player.clone(); 396 396 - let cloned_kv = kv.clone(); 397 397 - let cloned_playlist_store = playlist_store.clone(); 398 398 - pool.execute(move || { 399 399 - let mut buf_reader = BufReader::new(&stream); 400 400 - let mut request = String::new(); 401 401 - 402 402 - if buf_reader.read_line(&mut request).is_err() { 403 403 - let mut active_connections = active_connections.lock().unwrap(); 404 404 - *active_connections -= 1; 405 405 - return; 406 406 - } 407 407 - 408 408 - let request_line_parts: Vec<&str> = request.split_whitespace().collect(); 409 409 - if request_line_parts.len() >= 2 { 410 410 - let method = request_line_parts[0]; 411 411 - let path_with_query = request_line_parts[1]; 412 412 - 413 413 - let (path, query_string) = split_path_and_query(path_with_query); 414 414 - 415 415 - let query_params: Value = match query_string { 416 416 - Some(query_str) => queryst::parse(query_str).unwrap_or_default(), 417 417 - None => Value::default(), 418 418 - }; 419 419 - 420 420 - let mut content_length = 0; 421 421 - 422 422 - loop { 423 423 - let mut line = Default::default(); 424 424 - let res = buf_reader.read_line(&mut line); 425 425 - if res.is_ok() { 426 426 - if line.starts_with("Content-Length") 427 427 - || line.starts_with("content-length") 428 428 - { 429 429 - let parts: Vec<_> = line.split(":").collect(); 430 430 - content_length = parts[1].trim().parse().unwrap_or(0); 431 431 - } 432 432 - 433 433 - if line.as_str() == "\r\n" || line == "\n" { 434 434 - break; 435 435 - } 436 436 - } else { 437 437 - break; 438 438 - } 439 439 - } 440 440 - 441 441 - let mut body: Vec<u8> = vec![0; content_length]; 442 442 - let mut total_read: usize = 0; 443 443 - 444 444 - while total_read < content_length { 445 445 - match buf_reader.read(&mut body[total_read..]) { 446 446 - Ok(0) => break, 447 447 - Ok(n) => total_read += n, 448 448 - Err(_) => break, 449 449 - } 450 450 - } 451 451 - 452 452 - let req_body = match content_length { 453 453 - 0 => None, 454 454 - _ => Some(String::from_utf8_lossy(&body).to_string()), 455 455 - }; 456 456 - 457 457 - cloned_self.handle_request( 458 458 - method, 459 459 - path, 460 460 - query_params, 461 461 - stream, 462 462 - db_pool, 463 463 - req_body, 464 464 - cloned_rt, 465 465 - cloned_fs_cache, 466 466 - cloned_metadata_cache, 467 467 - cloned_devices, 468 468 - cloned_current_device, 469 469 - cloned_player, 470 470 - cloned_kv, 471 471 - cloned_playlist_store, 472 472 - ); 473 473 - } 474 474 - 475 475 - { 476 476 - let mut active_connections = active_connections.lock().unwrap(); 477 477 - *active_connections -= 1; 478 478 - } 479 479 - }); 480 480 - } 481 481 - Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => { 482 482 - // No incoming connection, just sleep and retry 483 483 - rb::system::sleep(rb::HZ); 484 484 - } 485 485 - Err(e) => { 486 486 - error!("Error accepting connection: {}", e); 487 487 - break; 488 488 - } 489 489 - } 490 490 - 491 491 - // Check if there are no active connections (idle state) 492 492 - let active = *active_connections.lock().unwrap(); 493 493 - if active == 0 { 494 494 - rb::system::sleep(rb::HZ); 495 495 - } 496 496 - 497 497 - // Add a small sleep to avoid tight looping when idle 498 498 - thread::sleep(Duration::from_millis(100)); 499 499 - } 500 500 - 501 501 - Ok(()) 502 502 - } 503 503 - 504 504 - // Handle incoming requests 505 505 - fn handle_request( 506 506 - &mut self, 507 507 - method: &str, 508 508 - path: &str, 509 509 - query_params: Value, 510 510 - mut stream: TcpStream, 511 511 - pool: sqlx::Pool<Sqlite>, 512 512 - body: Option<String>, 513 513 - rt: Arc<tokio::runtime::Runtime>, 514 514 - fs_cache: Arc<tokio::sync::Mutex<HashMap<String, Vec<Entry>>>>, 515 515 - metadata_cache: Arc<tokio::sync::Mutex<HashMap<String, Mp3Entry>>>, 516 516 - devices: Arc<Mutex<Vec<Device>>>, 517 517 - current_device: Arc<Mutex<Option<Device>>>, 518 518 - player: Arc<Mutex<Option<Box<dyn Player + Send>>>>, 519 519 - kv: Arc<Mutex<KV<Track>>>, 520 520 - playlist_store: PlaylistStore, 521 521 - ) { 522 522 - debug!("{} {}", method, path); 523 523 - match self.router.route(method, path) { 524 524 - Some((handler, params)) => { 525 525 - let mut response = Response::new(); 526 526 - let context = Context { 527 527 - pool, 528 528 - rt, 529 529 - fs_cache, 530 530 - metadata_cache, 531 531 - devices, 532 532 - current_device, 533 533 - player, 534 534 - kv, 535 535 - playlist_store, 536 536 - }; 537 537 - let request = Request { 538 538 - method: method.to_string(), 539 539 - params, 540 540 - query_params, 541 541 - body, 542 542 - }; 543 543 - match handler(&context, &request, &mut response) { 544 544 - Ok(_) => { 545 545 - response.send(&mut stream); 546 546 - } 547 547 - Err(e) => { 548 548 - let mut response = Response::new(); 549 549 - response.set_status(500); 550 550 - response.set_body(&format!("Internal Server Error: {:?}", e)); 551 551 - response.send(&mut stream); 552 552 - } 553 553 - } 554 554 - } 555 555 - None => { 556 556 - let mut response = Response::new(); 557 557 - response.set_status(404); 558 558 - response.set_body("404 Not Found"); 559 559 - response.send(&mut stream); 560 560 - } 561 561 - }; 562 562 - } 563 563 - }

+429 -102

crates/server/src/lib.rs

reviewed

··· 1 1 use anyhow::Error; 2 2 - use handlers::*; 3 2 use tracing::{error, warn}; 4 3 5 5 - use http::RockboxHttpServer; 6 4 use lazy_static::lazy_static; 7 5 use rockbox_graphql::{ 8 6 schema::objects::{self, audio_status::AudioStatus, track::Track}, ··· 79 77 } 80 78 } 81 79 82 82 - let mut app = RockboxHttpServer::new(); 80 80 + // Pre-initialize the UPnP tokio runtime before any other runtime starts. 81 81 + rockbox_upnp::init(); 83 82 84 84 - app.get("/albums", get_albums); 85 85 - app.get("/albums/:id", get_album); 86 86 - app.get("/albums/:id/tracks", get_album_tracks); 83 83 + // Run the HTTP server in its own Rust OS thread so actix gets a proper 84 84 + // multi-worker runtime instead of collapsing onto the Rockbox C thread. 85 85 + thread::spawn( 86 86 + || match actix_rt::System::new().block_on(run_http_server()) { 87 87 + Ok(_) => {} 88 88 + Err(e) => { 89 89 + error!("Error starting HTTP server: {}", e); 90 90 + } 91 91 + }, 92 92 + ); 87 93 88 88 - app.get("/artists", get_artists); 89 89 - app.get("/artists/:id", get_artist); 90 90 - app.get("/artists/:id/albums", get_artist_albums); 91 91 - app.get("/artists/:id/tracks", get_artist_tracks); 94 94 + // Yield to the Rockbox cooperative scheduler periodically. Without this 95 95 + // the server_thread holds the Rockbox CPU token indefinitely and starves 96 96 + // every other kernel thread (broker, gRPC, etc.). The old accept loop 97 97 + // called rb::system::sleep(rb::HZ) on every idle iteration; we replicate 98 98 + // that contract here. 99 99 + loop { 100 100 + thread::sleep(std::time::Duration::from_millis(100)); 101 101 + rb::system::sleep(rb::HZ); 102 102 + } 103 103 + } 92 104 93 93 - app.get("/browse/tree-entries", get_tree_entries); 105 105 + async fn run_http_server() -> Result<(), Error> { 106 106 + use crate::http::AppState; 107 107 + use actix_cors::Cors; 108 108 + use actix_web::{web, App, HttpServer}; 109 109 + use rockbox_types::device::Device; 94 110 95 95 - app.get("/player", get_current_player); 96 96 - app.put("/player/load", load); 97 97 - app.put("/player/play", play); 98 98 - app.put("/player/pause", pause); 99 99 - app.put("/player/resume", resume); 100 100 - app.put("/player/ff-rewind", ff_rewind); 101 101 - app.get("/player/status", status); 102 102 - app.get("/player/current-track", current_track); 103 103 - app.get("/player/next-track", next_track); 104 104 - app.put("/player/flush-and-reload-tracks", flush_and_reload_tracks); 105 105 - app.put("/player/next", next); 106 106 - app.put("/player/previous", previous); 107 107 - app.put("/player/stop", stop); 108 108 - app.get("/player/file-position", get_file_position); 109 109 - app.get("/player/volume", get_volume); 110 110 - app.put("/player/volume", adjust_volume); 111 111 + let port = std::env::var("ROCKBOX_TCP_PORT").unwrap_or_else(|_| "6063".to_string()); 112 112 + let addr = format!("0.0.0.0:{}", port); 111 113 112 112 - app.post("/playlists", create_playlist); 113 113 - app.put("/playlists/start", start_playlist); 114 114 - app.put("/playlists/shuffle", shuffle_playlist); 115 115 - app.get("/playlists/amount", get_playlist_amount); 116 116 - app.put("/playlists/resume", resume_playlist); 117 117 - app.put("/playlists/resume-track", resume_track); 118 118 - app.get("/playlists/:id/tracks", get_playlist_tracks); 119 119 - app.post("/playlists/:id/tracks", insert_tracks); 120 120 - app.delete("/playlists/:id/tracks", remove_tracks); 121 121 - app.get("/playlists/:id", get_playlist); 114 114 + let pool = rockbox_library::create_connection_pool().await?; 115 115 + let fs_cache = Arc::new(tokio::sync::Mutex::new(HashMap::new())); 116 116 + let metadata_cache = Arc::new(tokio::sync::Mutex::new(HashMap::new())); 117 117 + let devices = Arc::new(Mutex::new(scan::virtual_devices())); 122 118 123 123 - app.get("/saved-playlists/folders", list_playlist_folders); 124 124 - app.post("/saved-playlists/folders", create_playlist_folder); 125 125 - app.delete("/saved-playlists/folders/:id", delete_playlist_folder); 126 126 - app.get("/saved-playlists", list_saved_playlists); 127 127 - app.post("/saved-playlists", create_saved_playlist); 128 128 - app.get("/saved-playlists/:id/tracks", get_saved_playlist_tracks); 129 129 - app.get( 130 130 - "/saved-playlists/:id/track-ids", 131 131 - get_saved_playlist_track_ids, 132 132 - ); 133 133 - app.post("/saved-playlists/:id/tracks", add_tracks_to_saved_playlist); 134 134 - app.delete( 135 135 - "/saved-playlists/:id/tracks/:track_id", 136 136 - remove_track_from_saved_playlist, 137 137 - ); 138 138 - app.post("/saved-playlists/:id/play", play_saved_playlist); 139 139 - app.get("/saved-playlists/:id", get_saved_playlist); 140 140 - app.put("/saved-playlists/:id", update_saved_playlist); 141 141 - app.delete("/saved-playlists/:id", delete_saved_playlist); 119 119 + let current_device = { 120 120 + let active = rockbox_settings::read_settings().ok().and_then(|s| { 121 121 + let output = s.audio_output.as_deref().unwrap_or("builtin"); 122 122 + let mut device = match output { 123 123 + "builtin" | "fifo" => scan::virtual_devices() 124 124 + .into_iter() 125 125 + .find(|d| d.service == output), 126 126 + "airplay" => { 127 127 + let host = s.airplay_host.clone().unwrap_or_default(); 128 128 + Some(Device { 129 129 + id: format!("airplay-{}", host), 130 130 + name: if host.is_empty() { 131 131 + "AirPlay".to_string() 132 132 + } else { 133 133 + format!("AirPlay ({})", host) 134 134 + }, 135 135 + host: host.clone(), 136 136 + ip: host, 137 137 + port: s.airplay_port.unwrap_or(5000), 138 138 + service: "airplay".to_string(), 139 139 + app: "AirPlay".to_string(), 140 140 + ..Default::default() 141 141 + }) 142 142 + } 143 143 + "squeezelite" => Some(Device { 144 144 + id: "squeezelite".to_string(), 145 145 + name: "Squeezelite".to_string(), 146 146 + host: "localhost".to_string(), 147 147 + ip: "127.0.0.1".to_string(), 148 148 + port: s.squeezelite_port.unwrap_or(3483), 149 149 + service: "squeezelite".to_string(), 150 150 + app: "squeezelite".to_string(), 151 151 + ..Default::default() 152 152 + }), 153 153 + "upnp" => { 154 154 + let url = s.upnp_renderer_url.clone().unwrap_or_default(); 155 155 + Some(Device { 156 156 + id: format!("upnp-{:.8}", format!("{:x}", md5::compute(url.as_bytes()))), 157 157 + name: "UPnP/DLNA".to_string(), 158 158 + host: "localhost".to_string(), 159 159 + ip: "127.0.0.1".to_string(), 160 160 + port: 0, 161 161 + service: "upnp".to_string(), 162 162 + app: "upnp".to_string(), 163 163 + base_url: Some(url), 164 164 + ..Default::default() 165 165 + }) 166 166 + } 167 167 + "chromecast" => { 168 168 + let host = s.chromecast_host.clone().unwrap_or_default(); 169 169 + Some(Device { 170 170 + id: format!("chromecast-{}", host), 171 171 + name: if host.is_empty() { 172 172 + "Chromecast".to_string() 173 173 + } else { 174 174 + format!("Chromecast ({})", host) 175 175 + }, 176 176 + host: host.clone(), 177 177 + ip: host, 178 178 + port: s.chromecast_port.unwrap_or(8009), 179 179 + service: "chromecast".to_string(), 180 180 + app: "Chromecast".to_string(), 181 181 + is_cast_device: true, 182 182 + ..Default::default() 183 183 + }) 184 184 + } 185 185 + "snapcast_tcp" => { 186 186 + let host = s.snapcast_tcp_host.clone().unwrap_or_default(); 187 187 + Some(Device { 188 188 + id: format!("snapcast-{}", host), 189 189 + name: if host.is_empty() { 190 190 + "Snapcast".to_string() 191 191 + } else { 192 192 + format!("Snapcast ({})", host) 193 193 + }, 194 194 + host: host.clone(), 195 195 + ip: host, 196 196 + port: s.snapcast_tcp_port.unwrap_or(4953), 197 197 + service: "snapcast".to_string(), 198 198 + app: "Snapcast".to_string(), 199 199 + is_cast_device: true, 200 200 + ..Default::default() 201 201 + }) 202 202 + } 203 203 + _ => scan::virtual_devices() 204 204 + .into_iter() 205 205 + .find(|d| d.service == "builtin"), 206 206 + }; 207 207 + if let Some(ref mut d) = device { 208 208 + d.is_current_device = true; 209 209 + } 210 210 + device 211 211 + }); 212 212 + Arc::new(Mutex::new(active)) 213 213 + }; 142 214 143 143 - app.get("/smart-playlists", list_smart_playlists); 144 144 - app.post("/smart-playlists", create_smart_playlist); 145 145 - app.get("/smart-playlists/:id/tracks", get_smart_playlist_tracks); 146 146 - app.post("/smart-playlists/:id/play", play_smart_playlist); 147 147 - app.get("/smart-playlists/:id", get_smart_playlist); 148 148 - app.put("/smart-playlists/:id", update_smart_playlist); 149 149 - app.delete("/smart-playlists/:id", delete_smart_playlist); 215 215 + let player = Arc::new(Mutex::new(None)); 216 216 + let kv = Arc::new(Mutex::new(kv::build_tracks_kv(pool.clone()).await?)); 150 217 151 151 - app.post("/track-stats/:id/played", record_track_played); 152 152 - app.post("/track-stats/:id/skipped", record_track_skipped); 153 153 - app.get("/track-stats/:id", get_track_stats); 218 218 + let playlist_store = rockbox_playlists::PlaylistStore::new(pool.clone()); 219 219 + playlist_store.seed().await?; 220 220 + 221 221 + scan::scan_chromecast_devices(devices.clone()); 222 222 + scan::scan_upnp_devices(devices.clone()); 223 223 + scan::scan_airplay_devices(devices.clone()); 224 224 + scan::scan_snapcast_servers(devices.clone()); 225 225 + scan::scan_squeezelite_clients(devices.clone()); 226 226 + player_events::listen_for_playback_changes(player.clone(), pool.clone()); 154 227 155 155 - app.get("/tracks", get_tracks); 156 156 - app.get("/tracks/:id", get_track); 157 157 - app.put("/tracks/stream-metadata", save_stream_track_metadata); 228 228 + let state = web::Data::new(AppState { 229 229 + pool, 230 230 + fs_cache, 231 231 + metadata_cache, 232 232 + devices, 233 233 + current_device, 234 234 + player, 235 235 + kv, 236 236 + playlist_store, 237 237 + }); 158 238 159 159 - app.get("/version", get_rockbox_version); 160 160 - app.get("/status", get_status); 161 161 - app.get("/settings", get_global_settings); 162 162 - app.put("/settings", update_global_settings); 163 163 - app.put("/scan-library", scan_library); 164 164 - app.get("/search", search); 239 239 + HttpServer::new(move || { 240 240 + let cors = Cors::permissive(); 241 241 + App::new() 242 242 + .app_data(state.clone()) 243 243 + .wrap(cors) 244 244 + // Albums 245 245 + .route("/albums", web::get().to(handlers::albums::get_albums)) 246 246 + .route("/albums/{id}", web::get().to(handlers::albums::get_album)) 247 247 + .route( 248 248 + "/albums/{id}/tracks", 249 249 + web::get().to(handlers::albums::get_album_tracks), 250 250 + ) 251 251 + // Artists 252 252 + .route("/artists", web::get().to(handlers::artists::get_artists)) 253 253 + .route( 254 254 + "/artists/{id}", 255 255 + web::get().to(handlers::artists::get_artist), 256 256 + ) 257 257 + .route( 258 258 + "/artists/{id}/albums", 259 259 + web::get().to(handlers::artists::get_artist_albums), 260 260 + ) 261 261 + .route( 262 262 + "/artists/{id}/tracks", 263 263 + web::get().to(handlers::artists::get_artist_tracks), 264 264 + ) 265 265 + // Browse 266 266 + .route( 267 267 + "/browse/tree-entries", 268 268 + web::get().to(handlers::browse::get_tree_entries), 269 269 + ) 270 270 + // Player 271 271 + .route( 272 272 + "/player", 273 273 + web::get().to(handlers::player::get_current_player), 274 274 + ) 275 275 + .route("/player/load", web::put().to(handlers::player::load)) 276 276 + .route("/player/play", web::put().to(handlers::player::play)) 277 277 + .route("/player/pause", web::put().to(handlers::player::pause)) 278 278 + .route("/player/resume", web::put().to(handlers::player::resume)) 279 279 + .route( 280 280 + "/player/ff-rewind", 281 281 + web::put().to(handlers::player::ff_rewind), 282 282 + ) 283 283 + .route("/player/status", web::get().to(handlers::player::status)) 284 284 + .route( 285 285 + "/player/current-track", 286 286 + web::get().to(handlers::player::current_track), 287 287 + ) 288 288 + .route( 289 289 + "/player/next-track", 290 290 + web::get().to(handlers::player::next_track), 291 291 + ) 292 292 + .route( 293 293 + "/player/flush-and-reload-tracks", 294 294 + web::put().to(handlers::player::flush_and_reload_tracks), 295 295 + ) 296 296 + .route("/player/next", web::put().to(handlers::player::next)) 297 297 + .route( 298 298 + "/player/previous", 299 299 + web::put().to(handlers::player::previous), 300 300 + ) 301 301 + .route("/player/stop", web::put().to(handlers::player::stop)) 302 302 + .route( 303 303 + "/player/file-position", 304 304 + web::get().to(handlers::player::get_file_position), 305 305 + ) 306 306 + .route( 307 307 + "/player/volume", 308 308 + web::get().to(handlers::player::get_volume), 309 309 + ) 310 310 + .route( 311 311 + "/player/volume", 312 312 + web::put().to(handlers::player::adjust_volume), 313 313 + ) 314 314 + // Playlists — fixed routes before parametric ones 315 315 + .route( 316 316 + "/playlists/start", 317 317 + web::put().to(handlers::playlists::start_playlist), 318 318 + ) 319 319 + .route( 320 320 + "/playlists/shuffle", 321 321 + web::put().to(handlers::playlists::shuffle_playlist), 322 322 + ) 323 323 + .route( 324 324 + "/playlists/amount", 325 325 + web::get().to(handlers::playlists::get_playlist_amount), 326 326 + ) 327 327 + .route( 328 328 + "/playlists/resume", 329 329 + web::put().to(handlers::playlists::resume_playlist), 330 330 + ) 331 331 + .route( 332 332 + "/playlists/resume-track", 333 333 + web::put().to(handlers::playlists::resume_track), 334 334 + ) 335 335 + .route( 336 336 + "/playlists", 337 337 + web::post().to(handlers::playlists::create_playlist), 338 338 + ) 339 339 + .route( 340 340 + "/playlists/{id}/tracks", 341 341 + web::get().to(handlers::playlists::get_playlist_tracks), 342 342 + ) 343 343 + .route( 344 344 + "/playlists/{id}/tracks", 345 345 + web::post().to(handlers::playlists::insert_tracks), 346 346 + ) 347 347 + .route( 348 348 + "/playlists/{id}/tracks", 349 349 + web::delete().to(handlers::playlists::remove_tracks), 350 350 + ) 351 351 + .route( 352 352 + "/playlists/{id}", 353 353 + web::get().to(handlers::playlists::get_playlist), 354 354 + ) 355 355 + // Saved playlists — fixed routes before parametric ones 356 356 + .route( 357 357 + "/saved-playlists/folders", 358 358 + web::get().to(handlers::saved_playlists::list_playlist_folders), 359 359 + ) 360 360 + .route( 361 361 + "/saved-playlists/folders", 362 362 + web::post().to(handlers::saved_playlists::create_playlist_folder), 363 363 + ) 364 364 + .route( 365 365 + "/saved-playlists/folders/{id}", 366 366 + web::delete().to(handlers::saved_playlists::delete_playlist_folder), 367 367 + ) 368 368 + .route( 369 369 + "/saved-playlists", 370 370 + web::get().to(handlers::saved_playlists::list_saved_playlists), 371 371 + ) 372 372 + .route( 373 373 + "/saved-playlists", 374 374 + web::post().to(handlers::saved_playlists::create_saved_playlist), 375 375 + ) 376 376 + .route( 377 377 + "/saved-playlists/{id}/tracks", 378 378 + web::get().to(handlers::saved_playlists::get_saved_playlist_tracks), 379 379 + ) 380 380 + .route( 381 381 + "/saved-playlists/{id}/track-ids", 382 382 + web::get().to(handlers::saved_playlists::get_saved_playlist_track_ids), 383 383 + ) 384 384 + .route( 385 385 + "/saved-playlists/{id}/tracks", 386 386 + web::post().to(handlers::saved_playlists::add_tracks_to_saved_playlist), 387 387 + ) 388 388 + .route( 389 389 + "/saved-playlists/{id}/tracks/{track_id}", 390 390 + web::delete().to(handlers::saved_playlists::remove_track_from_saved_playlist), 391 391 + ) 392 392 + .route( 393 393 + "/saved-playlists/{id}/play", 394 394 + web::post().to(handlers::saved_playlists::play_saved_playlist), 395 395 + ) 396 396 + .route( 397 397 + "/saved-playlists/{id}", 398 398 + web::get().to(handlers::saved_playlists::get_saved_playlist), 399 399 + ) 400 400 + .route( 401 401 + "/saved-playlists/{id}", 402 402 + web::put().to(handlers::saved_playlists::update_saved_playlist), 403 403 + ) 404 404 + .route( 405 405 + "/saved-playlists/{id}", 406 406 + web::delete().to(handlers::saved_playlists::delete_saved_playlist), 407 407 + ) 408 408 + // Smart playlists 409 409 + .route( 410 410 + "/smart-playlists", 411 411 + web::get().to(handlers::smart_playlists::list_smart_playlists), 412 412 + ) 413 413 + .route( 414 414 + "/smart-playlists", 415 415 + web::post().to(handlers::smart_playlists::create_smart_playlist), 416 416 + ) 417 417 + .route( 418 418 + "/smart-playlists/{id}/tracks", 419 419 + web::get().to(handlers::smart_playlists::get_smart_playlist_tracks), 420 420 + ) 421 421 + .route( 422 422 + "/smart-playlists/{id}/play", 423 423 + web::post().to(handlers::smart_playlists::play_smart_playlist), 424 424 + ) 425 425 + .route( 426 426 + "/smart-playlists/{id}", 427 427 + web::get().to(handlers::smart_playlists::get_smart_playlist), 428 428 + ) 429 429 + .route( 430 430 + "/smart-playlists/{id}", 431 431 + web::put().to(handlers::smart_playlists::update_smart_playlist), 432 432 + ) 433 433 + .route( 434 434 + "/smart-playlists/{id}", 435 435 + web::delete().to(handlers::smart_playlists::delete_smart_playlist), 436 436 + ) 437 437 + // Track stats 438 438 + .route( 439 439 + "/track-stats/{id}/played", 440 440 + web::post().to(handlers::smart_playlists::record_track_played), 441 441 + ) 442 442 + .route( 443 443 + "/track-stats/{id}/skipped", 444 444 + web::post().to(handlers::smart_playlists::record_track_skipped), 445 445 + ) 446 446 + .route( 447 447 + "/track-stats/{id}", 448 448 + web::get().to(handlers::smart_playlists::get_track_stats), 449 449 + ) 450 450 + // Tracks — fixed route before parametric 451 451 + .route( 452 452 + "/tracks/stream-metadata", 453 453 + web::put().to(handlers::tracks::save_stream_track_metadata), 454 454 + ) 455 455 + .route("/tracks", web::get().to(handlers::tracks::get_tracks)) 456 456 + .route("/tracks/{id}", web::get().to(handlers::tracks::get_track)) 457 457 + // System 458 458 + .route( 459 459 + "/version", 460 460 + web::get().to(handlers::system::get_rockbox_version), 461 461 + ) 462 462 + .route("/status", web::get().to(handlers::system::get_status)) 463 463 + .route( 464 464 + "/settings", 465 465 + web::get().to(handlers::settings::get_global_settings), 466 466 + ) 467 467 + .route( 468 468 + "/settings", 469 469 + web::put().to(handlers::settings::update_global_settings), 470 470 + ) 471 471 + .route( 472 472 + "/scan-library", 473 473 + web::put().to(handlers::system::scan_library), 474 474 + ) 475 475 + .route("/search", web::get().to(handlers::search::search)) 476 476 + // Devices 477 477 + .route("/devices", web::get().to(handlers::devices::get_devices)) 478 478 + .route( 479 479 + "/devices/{id}", 480 480 + web::get().to(handlers::devices::get_device), 481 481 + ) 482 482 + .route( 483 483 + "/devices/{id}/connect", 484 484 + web::put().to(handlers::devices::connect), 485 485 + ) 486 486 + .route( 487 487 + "/devices/{id}/disconnect", 488 488 + web::put().to(handlers::devices::disconnect), 489 489 + ) 490 490 + // Docs 491 491 + .route("/", web::get().to(handlers::docs::index)) 492 492 + .route("/operations/{id}", web::get().to(handlers::docs::index)) 493 493 + .route("/schemas/{id}", web::get().to(handlers::docs::index)) 494 494 + .route("/openapi.json", web::get().to(handlers::docs::get_openapi)) 495 495 + .configure(bluetooth_routes) 496 496 + }) 497 497 + .bind(addr)? 498 498 + .run() 499 499 + .await?; 165 500 166 166 - app.get("/devices", get_devices); 167 167 - app.get("/devices/:id", get_device); 168 168 - app.put("/devices/:id/connect", connect); 169 169 - app.put("/devices/:id/disconnect", disconnect); 501 501 + Ok(()) 502 502 + } 170 503 504 504 + fn bluetooth_routes(_cfg: &mut actix_web::web::ServiceConfig) { 171 505 #[cfg(target_os = "linux")] 172 506 { 173 173 - app.post("/bluetooth/scan", scan_bluetooth); 174 174 - app.get("/bluetooth/devices", get_bluetooth_devices); 175 175 - app.put("/bluetooth/devices/:addr/connect", connect_bluetooth_device); 176 176 - app.put( 177 177 - "/bluetooth/devices/:addr/disconnect", 178 178 - disconnect_bluetooth_device, 507 507 + let cfg = _cfg; 508 508 + cfg.route( 509 509 + "/bluetooth/scan", 510 510 + actix_web::web::post().to(handlers::bluetooth::scan_bluetooth), 511 511 + ) 512 512 + .route( 513 513 + "/bluetooth/devices", 514 514 + actix_web::web::get().to(handlers::bluetooth::get_bluetooth_devices), 515 515 + ) 516 516 + .route( 517 517 + "/bluetooth/devices/{addr}/connect", 518 518 + actix_web::web::put().to(handlers::bluetooth::connect_bluetooth_device), 519 519 + ) 520 520 + .route( 521 521 + "/bluetooth/devices/{addr}/disconnect", 522 522 + actix_web::web::put().to(handlers::bluetooth::disconnect_bluetooth_device), 179 523 ); 180 180 - } 181 181 - 182 182 - app.get("/", index); 183 183 - app.get("/operations/:id", index); 184 184 - app.get("/schemas/:id", index); 185 185 - app.get("/openapi.json", get_openapi); 186 186 - 187 187 - // Pre-initialize the UPnP tokio runtime before any HTTP handler runs. 188 188 - // If initialized lazily inside a handler's block_on context, tokio 1.27+ 189 189 - // panics with "Cannot start a runtime from within a runtime." 190 190 - rockbox_upnp::init(); 191 191 - 192 192 - match app.listen() { 193 193 - Ok(_) => {} 194 194 - Err(e) => { 195 195 - error!("Error starting server: {}", e); 196 196 - } 197 524 } 198 525 } 199 526