+109

CLAUDE.md

reviewed

··· 259 259 bunx expo export --platform web # smoke-test the bundle (catches NativeWind transform issues) 260 260 ``` 261 261 262 262 + ### Native gRPC client — `crates/expo/` + `expo/modules/rockbox-rpc/` 263 263 + 264 264 + The mobile app talks to rockboxd through a native module that wraps a real 265 265 + tonic gRPC client written in Rust. It is split in two halves: 266 266 + 267 267 + **`crates/expo/`** — `rockbox-expo` Rust crate, `staticlib + cdylib`. 268 268 + - Generates client-only proto bindings in `build.rs` from the shared 269 269 + `crates/rpc/proto` tree (linked in via the `proto -> ../rpc/proto` symlink 270 270 + inside the crate so we don't duplicate `.proto` files). 271 271 + - Owns a single multi-thread Tokio runtime via `once_cell`. 272 272 + - Exposes a flat C ABI (`rb_set_server_url`, `rb_ping`, `rb_play`, `rb_pause`, 273 273 + `rb_play_pause`, `rb_next`, `rb_prev`, `rb_seek`, `rb_status_json`, 274 274 + `rb_current_track_json`, `rb_like_track`, `rb_unlike_track`, 275 275 + `rb_free_string`). Complex responses are returned as heap-allocated JSON 276 276 + C strings — caller MUST free via `rb_free_string`. Simple ops return `i32` 277 277 + status codes (0 = ok, <0 = error). 278 278 + - Deliberately does NOT depend on `rockbox-rpc` to avoid pulling sqlx / 279 279 + typesense / library transitive deps that fight cross-compilation. 280 280 + 281 281 + **`expo/modules/rockbox-rpc/`** — Expo SDK 54 native module. 282 282 + - `expo-module.config.json` declares iOS + Android module classes; the module 283 283 + is autolinked into the app via `expo/package.json` (`"rockbox-rpc": "file:./modules/rockbox-rpc"`). 284 284 + - iOS: `ios/RockboxRpcModule.swift` declares each `rb_*` symbol with 285 285 + `@_silgen_name(...)` and exposes them through `Function` / `AsyncFunction`. 286 286 + The static library is delivered as `ios/RockboxExpo.xcframework` (built by 287 287 + `scripts/build-ios.sh`); the `.podspec` `vendored_frameworks` it. 288 288 + - Android: `android/src/main/java/expo/modules/rockboxrpc/RockboxRpcModule.kt` 289 289 + uses `System.loadLibrary("rockbox_expo")` + JNI `external fun` declarations. 290 290 + The `.so` per ABI is dropped into `android/src/main/jniLibs/<abi>/` by 291 291 + `scripts/build-android.sh` (uses `cargo-ndk`). 292 292 + - TS facade: `expo/modules/rockbox-rpc/src/index.ts` declares the JS surface; 293 293 + `expo/lib/rockbox-client.ts` is the in-app helper with an `isAvailable` 294 294 + flag so callers can fall back to the mock `PlayerProvider` on web or when 295 295 + the libs haven't been built yet. 296 296 + 297 297 + #### Building the native libs 298 298 + 299 299 + ```sh 300 300 + # iOS — produces expo/modules/rockbox-rpc/ios/RockboxExpo.xcframework 301 301 + rustup target add aarch64-apple-ios aarch64-apple-ios-sim x86_64-apple-ios 302 302 + cd expo/modules/rockbox-rpc 303 303 + bun run build:ios 304 304 + 305 305 + # Android — produces expo/modules/rockbox-rpc/android/src/main/jniLibs/<abi>/librockbox_expo.so 306 306 + cargo install cargo-ndk 307 307 + rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android 308 308 + export ANDROID_NDK_HOME=... # NDK r25+ 309 309 + bun run build:android 310 310 + ``` 311 311 + 312 312 + After the native libs are in place, run `bunx expo prebuild` and then 313 313 + `bunx expo run:ios` / `run:android` to bundle them into the app. 314 314 + 315 315 + #### Adding new RPCs 316 316 + 317 317 + 1. Add a thin wrapper in `crates/expo/src/lib.rs` (`rb_<name>` returning 318 318 + `c_int` for unit ops or `*mut c_char` for JSON-bearing reads). 319 319 + 2. Add the matching extern declaration in both 320 320 + `expo/modules/rockbox-rpc/ios/RockboxRpcModule.swift` and 321 321 + `expo/modules/rockbox-rpc/android/src/main/java/.../RockboxRpcModule.kt`, 322 322 + plus an `AsyncFunction` binding. 323 323 + 3. Add the typed method to `expo/modules/rockbox-rpc/src/index.ts` and the 324 324 + forwarding helper in `expo/lib/rockbox-client.ts`. 325 325 + 4. Rebuild the native libs (`build:ios` / `build:android`) — `metro` doesn't 326 326 + pick up native changes automatically. 327 327 + 328 328 + #### Streaming subscriptions 329 329 + 330 330 + Server-streaming RPCs (`StreamStatus`, `StreamCurrentTrack`, `StreamPlaylist`) 331 331 + are exposed as JS events — not async iterators — to play nicely with React's 332 332 + render loop. The pipeline is: 333 333 + 334 334 + ``` 335 335 + tonic stream 336 336 + → tokio mpsc<String> (one queue per subscription, in crates/expo) 337 337 + → rb_poll_event(id, timeout_ms) -> *mut c_char 338 338 + → Swift dispatch_async / Kotlin Dispatchers.IO loop 339 339 + → sendEvent("rockbox.<topic>", payload) (Expo Modules EventEmitter) 340 340 + → RockboxRpc.addListener("rockbox.<topic>", cb) 341 341 + ``` 342 342 + 343 343 + Each `subscribe*` returns an opaque numeric subscription id; the JS facade in 344 344 + `expo/lib/rockbox-client.ts` wraps that with an `() => void` unsubscribe 345 345 + helper that removes both the event listener and the native subscription: 346 346 + 347 347 + ```ts 348 348 + const unsubscribe = RockboxClient.subscribeStatus( 349 349 + (s) => console.log("status", s.status), 350 350 + (e) => console.warn("stream error", e.error), 351 351 + ); 352 352 + // later: unsubscribe(); 353 353 + ``` 354 354 + 355 355 + Topics today: `rockbox.status`, `rockbox.currentTrack`, `rockbox.playlist`, 356 356 + `rockbox.library`, `rockbox.discovery` (LAN mDNS / Bonjour scan via the 357 357 + `rockbox-discovery` crate — emits one `DiscoveredService` per resolved peer), 358 358 + plus `rockbox.error` for stream failures (carries `subId`, `stream`, `error`). 359 359 + 360 360 + The `subscribeDiscovery` helper defaults to the `_rockbox._tcp.local.` 361 361 + service; pass any other Bonjour service name (e.g. `_googlecast._tcp.local.`) 362 362 + to scan for Chromecast / etc. Constants are also surfaced on the JS side via 363 363 + `RockboxClient.rockboxServiceName()` and `RockboxClient.chromecastServiceName()`. 364 364 + 365 365 + To add a new streamed RPC: add a `rb_subscribe_<name>` in `crates/expo/src/lib.rs` 366 366 + that follows the `spawn_stream(...)` pattern, declare the matching event topic 367 367 + in the iOS / Android `Events(...)` lists, register a `Function("subscribe<Name>")` 368 368 + in both modules, and add the typed `subscribe<Name>(cb, onError?)` helper to 369 369 + `expo/lib/rockbox-client.ts`. 370 370 + 262 371 ## Useful commands 263 372 264 373 ```sh

+15

Cargo.lock

reviewed

··· 9265 9265 ] 9266 9266 9267 9267 [[package]] 9268 9268 + name = "rockbox-expo" 9269 9269 + version = "0.1.0" 9270 9270 + dependencies = [ 9271 9271 + "futures-util", 9272 9272 + "once_cell", 9273 9273 + "prost", 9274 9274 + "rockbox-discovery", 9275 9275 + "serde", 9276 9276 + "serde_json", 9277 9277 + "tokio", 9278 9278 + "tonic", 9279 9279 + "tonic-build", 9280 9280 + ] 9281 9281 + 9282 9282 + [[package]] 9268 9283 name = "rockbox-graphql" 9269 9284 version = "0.1.0" 9270 9285 dependencies = [

+23

crates/expo/Cargo.toml

reviewed

··· 1 1 + [package] 2 2 + name = "rockbox-expo" 3 3 + version = "0.1.0" 4 4 + edition = "2021" 5 5 + description = "C-ABI gRPC client wrapper for embedding in the rockbox-zig Expo (React Native) mobile app" 6 6 + license = "LGPL-2.1" 7 7 + 8 8 + [lib] 9 9 + name = "rockbox_expo" 10 10 + crate-type = ["staticlib", "cdylib"] 11 11 + 12 12 + [dependencies] 13 13 + prost = "0.13" 14 14 + tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "time", "macros"] } 15 15 + tonic = { version = "0.12", default-features = false, features = ["transport", "codegen", "prost"] } 16 16 + once_cell = "1" 17 17 + serde = { version = "1", features = ["derive"] } 18 18 + serde_json = "1" 19 19 + futures-util = "0.3" 20 20 + rockbox-discovery = { path = "../discovery" } 21 21 + 22 22 + [build-dependencies] 23 23 + tonic-build = { version = "0.12", default-features = false, features = ["prost", "transport"] }

+136

crates/expo/README.md

reviewed

··· 1 1 + # `rockbox-expo` — C-ABI gRPC client for the Expo mobile app 2 2 + 3 3 + This crate produces a `staticlib` + `cdylib` that wraps the rockboxd gRPC 4 4 + client (built with [`tonic`]) and exposes a flat C ABI suitable for embedding 5 5 + in iOS (`.xcframework`) and Android (`jniLibs/<abi>/librockbox_expo.so`) 6 6 + builds. The companion [Expo Modules wrapper](../../expo/modules/rockbox-rpc/) 7 7 + loads the resulting library and forwards calls through React Native. 8 8 + 9 9 + It is the **mobile counterpart** to the desktop client in [`gpui/`](../../gpui/); 10 10 + the surface mirrors `gpui/src/client.rs` 1:1 wherever it makes sense. 11 11 + 12 12 + ## Why a separate crate? 13 13 + 14 14 + The `rockbox-rpc` crate (which the rockboxd server uses) pulls in heavy 15 15 + dependencies — `sqlx`, `typesense`, `library`, `reqwest` with native TLS, 16 16 + `rocksky`, etc. — that are painful to cross-compile to iOS / Android. This 17 17 + crate keeps deps minimal: 18 18 + 19 19 + - `tonic` (transport + codegen + prost), client only 20 20 + - `tokio` runtime (multi-thread, 2 worker threads) 21 21 + - `prost`, `serde`, `serde_json`, `once_cell`, `futures-util` 22 22 + - `rockbox-discovery` for LAN mDNS / Bonjour scans 23 23 + 24 24 + Proto bindings are generated from `proto/` (a symlink to 25 25 + `../rpc/proto`) via [`tonic-build`] in `build.rs`, with 26 26 + `build_server(false)` and a `type_attribute(".", "#[derive(serde::Serialize)]")` 27 27 + configuration so any response can be JSON-serialized in one line. 28 28 + 29 29 + ## Layout 30 30 + 31 31 + ``` 32 32 + crates/expo/ 33 33 + ├── Cargo.toml staticlib + cdylib, slim deps 34 34 + ├── build.rs tonic-build (client only) + serde derive on every proto 35 35 + ├── proto -> ../rpc/proto shared with the rest of the workspace 36 36 + └── src/lib.rs runtime, FFI surface, subscriptions 37 37 + ``` 38 38 + 39 39 + ## ABI conventions 40 40 + 41 41 + - All entry points are prefixed `rb_*` and exported with `#[no_mangle]`. 42 42 + - Unit operations return `i32` — `0` on success, negative on error. 43 43 + - Reads return `*mut c_char` — heap-owned JSON. Caller **must** free via 44 44 + `rb_free_string`. Errors come back as `{ "error": "..." }` JSON objects; 45 45 + the platform glue checks for that key and throws. 46 46 + - Strings flow in as `*const c_char` (NUL-terminated UTF-8); collections 47 47 + flow in as JSON-array C strings to keep the FFI narrow. 48 48 + 49 49 + ## Surface map 50 50 + 51 51 + | Group | Examples | 52 52 + |-------|----------| 53 53 + | Init | `rb_set_server_url`, `rb_ping` | 54 54 + | Playback | `rb_play / pause / play_pause / next / prev`, `rb_seek`, `rb_play_album / play_artist_tracks / play_track / play_directory` | 55 55 + | Queue | `rb_jump_to_queue_position`, `rb_insert_tracks`, `rb_insert_track_next / last`, `rb_remove_from_queue`, `rb_shuffle_playlist`, `rb_get_playlist_current_json` | 56 56 + | Library | `rb_get_tracks_json`, `rb_get_artists_json`, `rb_get_album_json`, `rb_search_json`, `rb_like_track / unlike_track`, `rb_get_liked_tracks_json` | 57 57 + | Sound / Settings | `rb_adjust_volume`, `rb_sound_current_json`, `rb_save_shuffle / save_repeat`, `rb_get_global_settings_json`, `rb_get_global_status_json` | 58 58 + | Browse | `rb_tree_get_entries_json` | 59 59 + | Saved playlists | `rb_get_saved_playlists_json`, `rb_create_saved_playlist`, `rb_update_saved_playlist`, `rb_delete_saved_playlist`, `rb_add_track_to_playlist`, `rb_remove_track_from_playlist`, `rb_get_saved_playlist_tracks_json`, `rb_play_saved_playlist` | 60 60 + | Smart playlists | `rb_get_smart_playlists_json`, `rb_get_smart_playlist_tracks_json`, `rb_play_smart_playlist` | 61 61 + | Bluetooth | `rb_bluetooth_available`, `rb_get_bluetooth_devices_json`, `rb_connect_bluetooth`, `rb_disconnect_bluetooth` | 62 62 + | Server-streaming | `rb_subscribe_status`, `rb_subscribe_current_track`, `rb_subscribe_playlist`, `rb_subscribe_library`, `rb_subscribe_discovery(serviceName)` | 63 63 + | Stream pump | `rb_poll_event(subId, timeoutMs)`, `rb_unsubscribe(subId)` | 64 64 + | Discovery constants | `rb_rockbox_service_name`, `rb_chromecast_service_name` | 65 65 + | Memory | `rb_free_string` | 66 66 + 67 67 + ## Streaming subscriptions 68 68 + 69 69 + Server-streaming RPCs and the mDNS scan share one model: 70 70 + 71 71 + ```text 72 72 + tonic / mdns-sd stream 73 73 + → tokio mpsc<String> (one queue per subscription) 74 74 + → rb_poll_event(id, timeout_ms) -> *mut c_char 75 75 + → Swift dispatch_async / Kotlin Dispatchers.IO loop 76 76 + → sendEvent("rockbox.<topic>", payload) 77 77 + ``` 78 78 + 79 79 + `rb_subscribe_*` returns an opaque `i32` subscription id. Each event JSON is 80 80 + the prost message for the topic (e.g. `StatusResponse`, `CurrentTrackResponse`, 81 81 + `PlaylistResponse`) or a `DiscoveredService` snapshot for the mDNS topic. 82 82 + 83 83 + Topics: `rockbox.status`, `rockbox.currentTrack`, `rockbox.playlist`, 84 84 + `rockbox.library`, `rockbox.discovery`. Stream errors propagate as 85 85 + `{ "error": "..." }` payloads on the same channel; the platform glue 86 86 + re-emits them on `rockbox.error`. 87 87 + 88 88 + ## Building 89 89 + 90 90 + Host-only sanity check: 91 91 + 92 92 + ```sh 93 93 + cargo check -p rockbox-expo 94 94 + ``` 95 95 + 96 96 + Cross-compile for mobile (driven by the [Expo module's build scripts](../../expo/modules/rockbox-rpc/scripts/)): 97 97 + 98 98 + ```sh 99 99 + # iOS — produces ../../expo/modules/rockbox-rpc/ios/RockboxExpo.xcframework 100 100 + rustup target add aarch64-apple-ios aarch64-apple-ios-sim x86_64-apple-ios 101 101 + ( cd ../../expo/modules/rockbox-rpc && bun run build:ios ) 102 102 + 103 103 + # Android — produces ../../expo/modules/rockbox-rpc/android/src/main/jniLibs/<abi>/librockbox_expo.so 104 104 + cargo install cargo-ndk 105 105 + rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android 106 106 + export ANDROID_NDK_HOME=... # NDK r25+ 107 107 + ( cd ../../expo/modules/rockbox-rpc && bun run build:android ) 108 108 + ``` 109 109 + 110 110 + ## Adding a new RPC 111 111 + 112 112 + 1. Add a `rb_<name>` wrapper in `src/lib.rs`. For unit ops, use the 113 113 + `simple_call!` macro or write `run_unit(async move { ... })`. For reads, 114 114 + `unwrap_or_err_string(res.map(|r| r.into_inner()))` does the JSON wrap. 115 115 + 2. Add the matching extern + `Function` / `AsyncFunction` in both 116 116 + `expo/modules/rockbox-rpc/ios/RockboxRpcModule.swift` and 117 117 + `.../RockboxRpcModule.kt`. 118 118 + 3. Add the typed signature to `expo/modules/rockbox-rpc/src/index.ts` and a 119 119 + one-line forwarder on `RockboxClient` in `expo/lib/rockbox-client.ts`. 120 120 + 4. Rebuild the native libs (`build:ios` / `build:android`); Metro doesn't 121 121 + pick up native changes automatically. 122 122 + 123 123 + For server-streaming RPCs, follow the `spawn_stream(...)` pattern, declare 124 124 + the matching event topic in `Events(...)` on both platforms, register a 125 125 + `Function("subscribe<Name>")` Function, and add a typed 126 126 + `subscribe<Name>(cb, onError?)` helper to `expo/lib/rockbox-client.ts`. 127 127 + 128 128 + ## Skipped vs. `gpui/src/client.rs` 129 129 + 130 130 + The HTTP-REST device endpoints (`fetch_devices`, `connect_device`, 131 131 + `disconnect_device`) are not gRPC and aren't covered by this crate. The 132 132 + `run_*_sync` driver loops are also not exposed — the JS side can call the 133 133 + underlying unary RPCs directly and orchestrate its own caching. 134 134 + 135 135 + [`tonic`]: https://docs.rs/tonic 136 136 + [`tonic-build`]: https://docs.rs/tonic-build

+36

crates/expo/build.rs

reviewed

··· 1 1 + fn main() -> Result<(), Box<dyn std::error::Error>> { 2 2 + // Generate client-only bindings from the shared proto files. The local 3 3 + // `proto` directory is a symlink to `../rpc/proto` so we read through the 4 4 + // same path the rest of the workspace uses (`crates/rpc/proto`) without 5 5 + // duplicating files. We deliberately avoid depending on `rockbox-rpc` to 6 6 + // keep the mobile crate slim (no sqlx / typesense / library transitive 7 7 + // deps that fight cross-compilation). 8 8 + let protos = [ 9 9 + "proto/rockbox/v1alpha1/browse.proto", 10 10 + "proto/rockbox/v1alpha1/library.proto", 11 11 + "proto/rockbox/v1alpha1/metadata.proto", 12 12 + "proto/rockbox/v1alpha1/playback.proto", 13 13 + "proto/rockbox/v1alpha1/playlist.proto", 14 14 + "proto/rockbox/v1alpha1/settings.proto", 15 15 + "proto/rockbox/v1alpha1/sound.proto", 16 16 + "proto/rockbox/v1alpha1/system.proto", 17 17 + "proto/rockbox/v1alpha1/saved_playlist.proto", 18 18 + "proto/rockbox/v1alpha1/smart_playlist.proto", 19 19 + "proto/rockbox/v1alpha1/bluetooth.proto", 20 20 + ]; 21 21 + 22 22 + // Derive serde::Serialize on every generated proto type so we can ship 23 23 + // entire responses to JS as JSON in one line. (Deserialize is not derived 24 24 + // — we only serialize *out* of Rust today.) 25 25 + tonic_build::configure() 26 26 + .build_server(false) 27 27 + .build_client(true) 28 28 + .type_attribute(".", "#[derive(serde::Serialize)]") 29 29 + .compile_protos(&protos, &["proto"])?; 30 30 + 31 31 + for p in &protos { 32 32 + println!("cargo:rerun-if-changed={p}"); 33 33 + } 34 34 + 35 35 + Ok(()) 36 36 + }

+1

crates/expo/proto

reviewed

··· 1 1 + ../rpc/proto

+1550

crates/expo/src/lib.rs

reviewed

··· 1 1 + //! Rockbox mobile client — C-ABI wrapper around a tonic gRPC client. 2 2 + //! 3 3 + //! Designed to be linked into iOS (.xcframework) and Android (jniLibs) builds 4 4 + //! and called from Expo modules' Swift / Kotlin glue. 5 5 + //! 6 6 + //! ## ABI 7 7 + //! 8 8 + //! - All entry points return either an `i32` status code (0 = ok, <0 = error) 9 9 + //! or a `*mut c_char` heap-owned C string. Callers MUST free returned strings 10 10 + //! via `rb_free_string`. 11 11 + //! - Complex responses (status snapshot, current track, etc.) are returned as 12 12 + //! JSON to avoid struct marshaling pain across language boundaries. 13 13 + //! - All synchronous fn names are prefixed `rb_*` and block on the embedded 14 14 + //! Tokio runtime — call from a background thread on the platform side. 15 15 + 16 16 + use std::collections::HashMap; 17 17 + use std::ffi::{CStr, CString}; 18 18 + use std::os::raw::{c_char, c_int}; 19 19 + use std::sync::atomic::{AtomicI32, Ordering}; 20 20 + use std::sync::RwLock; 21 21 + use std::time::Duration; 22 22 + 23 23 + use futures_util::pin_mut; 24 24 + use futures_util::StreamExt; 25 25 + use once_cell::sync::Lazy; 26 26 + use serde::Serialize; 27 27 + use tokio::runtime::Runtime; 28 28 + use tokio::sync::mpsc; 29 29 + use tokio::task::AbortHandle; 30 30 + 31 31 + pub mod api { 32 32 + pub mod v1alpha1 { 33 33 + tonic::include_proto!("rockbox.v1alpha1"); 34 34 + } 35 35 + } 36 36 + 37 37 + use api::v1alpha1::{ 38 38 + bluetooth_service_client::BluetoothServiceClient, browse_service_client::BrowseServiceClient, 39 39 + library_service_client::LibraryServiceClient, playback_service_client::PlaybackServiceClient, 40 40 + playlist_service_client::PlaylistServiceClient, 41 41 + saved_playlist_service_client::SavedPlaylistServiceClient, 42 42 + settings_service_client::SettingsServiceClient, 43 43 + smart_playlist_service_client::SmartPlaylistServiceClient, 44 44 + sound_service_client::SoundServiceClient, system_service_client::SystemServiceClient, 45 45 + AddTracksToSavedPlaylistRequest, AdjustVolumeRequest, ConnectBluetoothDeviceRequest, 46 46 + CreateSavedPlaylistRequest, CurrentTrackRequest, DeleteSavedPlaylistRequest, 47 47 + DisconnectBluetoothDeviceRequest, FastForwardRewindRequest, GetAlbumRequest, GetArtistsRequest, 48 48 + GetBluetoothDevicesRequest, GetCurrentRequest, GetGlobalSettingsRequest, 49 49 + GetGlobalStatusRequest, GetLikedTracksRequest, GetSavedPlaylistTracksRequest, 50 50 + GetSavedPlaylistsRequest, GetSmartPlaylistTracksRequest, GetSmartPlaylistsRequest, 51 51 + GetTracksRequest, InsertDirectoryRequest, InsertTracksRequest, LikeTrackRequest, NextRequest, 52 52 + PauseRequest, PlayAlbumRequest, PlayAllTracksRequest, PlayArtistTracksRequest, 53 53 + PlayDirectoryRequest, PlayOrPauseRequest, PlaySavedPlaylistRequest, PlaySmartPlaylistRequest, 54 54 + PlayTrackRequest, PlaylistResumeRequest, PreviousRequest, RemoveTrackFromSavedPlaylistRequest, 55 55 + RemoveTracksRequest, ResumeRequest, ResumeTrackRequest, SaveSettingsRequest, SearchRequest, 56 56 + ShufflePlaylistRequest, SoundCurrentRequest, StartRequest, StatusRequest, 57 57 + StreamCurrentTrackRequest, StreamLibraryRequest, StreamPlaylistRequest, StreamStatusRequest, 58 58 + TreeGetEntriesRequest, UnlikeTrackRequest, UpdateSavedPlaylistRequest, 59 59 + }; 60 60 + 61 61 + // ── Globals ────────────────────────────────────────────────────────────────── 62 62 + 63 63 + /// One Tokio runtime per process. Multi-thread is fine on Android; iOS works 64 64 + /// too — tokio uses pthread under the hood. 65 65 + static RT: Lazy<Runtime> = Lazy::new(|| { 66 66 + tokio::runtime::Builder::new_multi_thread() 67 67 + .enable_all() 68 68 + .worker_threads(2) 69 69 + .thread_name("rockbox-rpc") 70 70 + .build() 71 71 + .expect("failed to build tokio runtime") 72 72 + }); 73 73 + 74 74 + static SERVER_URL: Lazy<RwLock<String>> = 75 75 + Lazy::new(|| RwLock::new("http://127.0.0.1:6061".to_string())); 76 76 + 77 77 + fn url() -> String { 78 78 + SERVER_URL.read().expect("server url poisoned").clone() 79 79 + } 80 80 + 81 81 + // ── String helpers ─────────────────────────────────────────────────────────── 82 82 + 83 83 + unsafe fn cstr_to_str<'a>(p: *const c_char) -> Option<&'a str> { 84 84 + if p.is_null() { 85 85 + return None; 86 86 + } 87 87 + CStr::from_ptr(p).to_str().ok() 88 88 + } 89 89 + 90 90 + fn ok_string<T: Serialize>(value: &T) -> *mut c_char { 91 91 + match serde_json::to_string(value) { 92 92 + Ok(s) => CString::new(s) 93 93 + .map(|c| c.into_raw()) 94 94 + .unwrap_or(std::ptr::null_mut()), 95 95 + Err(_) => std::ptr::null_mut(), 96 96 + } 97 97 + } 98 98 + 99 99 + fn err_string(msg: impl AsRef<str>) -> *mut c_char { 100 100 + let payload = serde_json::json!({ "error": msg.as_ref() }); 101 101 + CString::new(payload.to_string()) 102 102 + .map(|c| c.into_raw()) 103 103 + .unwrap_or(std::ptr::null_mut()) 104 104 + } 105 105 + 106 106 + /// Frees a string previously returned by any `rb_*_json` entry point. 107 107 + /// Safe to call with a null pointer. 108 108 + /// 109 109 + /// # Safety 110 110 + /// `ptr` must be either null or a pointer returned by this library and must 111 111 + /// not have been freed already. 112 112 + #[no_mangle] 113 113 + pub unsafe extern "C" fn rb_free_string(ptr: *mut c_char) { 114 114 + if ptr.is_null() { 115 115 + return; 116 116 + } 117 117 + // Reclaim ownership and drop. 118 118 + drop(CString::from_raw(ptr)); 119 119 + } 120 120 + 121 121 + // ── Init / config ──────────────────────────────────────────────────────────── 122 122 + 123 123 + /// Configure the gRPC server URL. Call once at startup before any other entry. 124 124 + /// Returns 0 on success, -1 on invalid input. 125 125 + /// 126 126 + /// # Safety 127 127 + /// `url_ptr` must point to a valid NUL-terminated UTF-8 string. 128 128 + #[no_mangle] 129 129 + pub unsafe extern "C" fn rb_set_server_url(url_ptr: *const c_char) -> c_int { 130 130 + let Some(s) = cstr_to_str(url_ptr) else { 131 131 + return -1; 132 132 + }; 133 133 + match SERVER_URL.write() { 134 134 + Ok(mut g) => { 135 135 + *g = s.to_string(); 136 136 + 0 137 137 + } 138 138 + Err(_) => -2, 139 139 + } 140 140 + } 141 141 + 142 142 + /// Health check — round-trips a Status RPC. Returns 0 on success, -1 otherwise. 143 143 + #[no_mangle] 144 144 + pub extern "C" fn rb_ping() -> c_int { 145 145 + let res: Result<(), tonic::Status> = RT.block_on(async { 146 146 + let mut c = PlaybackServiceClient::connect(url()) 147 147 + .await 148 148 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 149 149 + c.status(StatusRequest {}).await?; 150 150 + Ok(()) 151 151 + }); 152 152 + match res { 153 153 + Ok(_) => 0, 154 154 + Err(_) => -1, 155 155 + } 156 156 + } 157 157 + 158 158 + // ── Playback control ───────────────────────────────────────────────────────── 159 159 + 160 160 + macro_rules! simple_call { 161 161 + ($fn_name:ident, $client:ident, $method:ident, $req:expr) => { 162 162 + #[no_mangle] 163 163 + pub extern "C" fn $fn_name() -> c_int { 164 164 + let res: Result<(), tonic::Status> = RT.block_on(async { 165 165 + let mut c = $client::connect(url()) 166 166 + .await 167 167 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 168 168 + c.$method($req).await?; 169 169 + Ok(()) 170 170 + }); 171 171 + match res { 172 172 + Ok(_) => 0, 173 173 + Err(_) => -1, 174 174 + } 175 175 + } 176 176 + }; 177 177 + } 178 178 + 179 179 + simple_call!(rb_play, PlaybackServiceClient, resume, ResumeRequest {}); 180 180 + simple_call!(rb_pause, PlaybackServiceClient, pause, PauseRequest {}); 181 181 + simple_call!( 182 182 + rb_play_pause, 183 183 + PlaybackServiceClient, 184 184 + play_or_pause, 185 185 + PlayOrPauseRequest {} 186 186 + ); 187 187 + simple_call!(rb_next, PlaybackServiceClient, next, NextRequest {}); 188 188 + simple_call!(rb_prev, PlaybackServiceClient, previous, PreviousRequest {}); 189 189 + 190 190 + /// Seek to `position_ms` milliseconds from the start of the current track. 191 191 + #[no_mangle] 192 192 + pub extern "C" fn rb_seek(position_ms: i32) -> c_int { 193 193 + let res: Result<(), tonic::Status> = RT.block_on(async { 194 194 + let mut c = PlaybackServiceClient::connect(url()) 195 195 + .await 196 196 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 197 197 + c.fast_forward_rewind(FastForwardRewindRequest { 198 198 + new_time: position_ms, 199 199 + }) 200 200 + .await?; 201 201 + Ok(()) 202 202 + }); 203 203 + match res { 204 204 + Ok(_) => 0, 205 205 + Err(_) => -1, 206 206 + } 207 207 + } 208 208 + 209 209 + // ── Read / status (returns JSON; caller must rb_free_string) ──────────────── 210 210 + 211 211 + #[derive(Serialize)] 212 212 + struct StatusJson { 213 213 + /// Server-side playback status code: 0 stopped, 1 playing, 2 paused. 214 214 + status: i32, 215 215 + } 216 216 + 217 217 + /// Returns a heap-allocated JSON string with global playback status, or an 218 218 + /// error JSON object on failure. Caller must free via `rb_free_string`. 219 219 + #[no_mangle] 220 220 + pub extern "C" fn rb_status_json() -> *mut c_char { 221 221 + let res: Result<StatusJson, tonic::Status> = RT.block_on(async { 222 222 + let mut c = PlaybackServiceClient::connect(url()) 223 223 + .await 224 224 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 225 225 + let resp = c.status(StatusRequest {}).await?.into_inner(); 226 226 + Ok(StatusJson { 227 227 + status: resp.status, 228 228 + }) 229 229 + }); 230 230 + match res { 231 231 + Ok(v) => ok_string(&v), 232 232 + Err(e) => err_string(format!("status: {e}")), 233 233 + } 234 234 + } 235 235 + 236 236 + #[derive(Serialize, Default)] 237 237 + struct TrackJson { 238 238 + id: String, 239 239 + path: String, 240 240 + title: String, 241 241 + artist: String, 242 242 + album: String, 243 243 + album_art: Option<String>, 244 244 + duration_ms: i64, 245 245 + elapsed_ms: i64, 246 246 + } 247 247 + 248 248 + /// Returns the current track as JSON (heap-allocated; free with `rb_free_string`). 249 249 + /// JSON shape: `{ id, path, title, artist, album, album_art, duration_ms }`. 250 250 + #[no_mangle] 251 251 + pub extern "C" fn rb_current_track_json() -> *mut c_char { 252 252 + let res: Result<TrackJson, tonic::Status> = RT.block_on(async { 253 253 + let mut c = PlaybackServiceClient::connect(url()) 254 254 + .await 255 255 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 256 256 + let resp = c.current_track(CurrentTrackRequest {}).await?.into_inner(); 257 257 + let album_art: Option<String> = resp.album_art.filter(|s: &String| !s.is_empty()); 258 258 + Ok(TrackJson { 259 259 + id: resp.id, 260 260 + path: resp.path, 261 261 + title: resp.title, 262 262 + artist: resp.artist, 263 263 + album: resp.album, 264 264 + album_art, 265 265 + duration_ms: resp.length as i64, 266 266 + elapsed_ms: resp.elapsed as i64, 267 267 + }) 268 268 + }); 269 269 + match res { 270 270 + Ok(v) => ok_string(&v), 271 271 + Err(_e) => { 272 272 + // Many fresh installs return `unimplemented` until a track is loaded; 273 273 + // surface an empty JSON object rather than an error so the UI degrades 274 274 + // gracefully. 275 275 + ok_string(&TrackJson::default()) 276 276 + } 277 277 + } 278 278 + } 279 279 + 280 280 + // ── Like / unlike ──────────────────────────────────────────────────────────── 281 281 + 282 282 + /// # Safety 283 283 + /// `track_id_ptr` must point to a valid NUL-terminated UTF-8 string. 284 284 + #[no_mangle] 285 285 + pub unsafe extern "C" fn rb_like_track(track_id_ptr: *const c_char) -> c_int { 286 286 + let Some(track_id) = cstr_to_str(track_id_ptr) else { 287 287 + return -1; 288 288 + }; 289 289 + let track_id = track_id.to_string(); 290 290 + let res: Result<(), tonic::Status> = RT.block_on(async { 291 291 + let mut c = LibraryServiceClient::connect(url()) 292 292 + .await 293 293 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 294 294 + c.like_track(LikeTrackRequest { id: track_id }).await?; 295 295 + Ok(()) 296 296 + }); 297 297 + if res.is_ok() { 298 298 + 0 299 299 + } else { 300 300 + -1 301 301 + } 302 302 + } 303 303 + 304 304 + /// # Safety 305 305 + /// `track_id_ptr` must point to a valid NUL-terminated UTF-8 string. 306 306 + #[no_mangle] 307 307 + pub unsafe extern "C" fn rb_unlike_track(track_id_ptr: *const c_char) -> c_int { 308 308 + let Some(track_id) = cstr_to_str(track_id_ptr) else { 309 309 + return -1; 310 310 + }; 311 311 + let track_id = track_id.to_string(); 312 312 + let res: Result<(), tonic::Status> = RT.block_on(async { 313 313 + let mut c = LibraryServiceClient::connect(url()) 314 314 + .await 315 315 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 316 316 + c.unlike_track(UnlikeTrackRequest { id: track_id }).await?; 317 317 + Ok(()) 318 318 + }); 319 319 + if res.is_ok() { 320 320 + 0 321 321 + } else { 322 322 + -1 323 323 + } 324 324 + } 325 325 + 326 326 + // ── Comprehensive RPC surface ─────────────────────────────────────────────── 327 327 + // 328 328 + // Mirrors `gpui/src/client.rs`. JSON-returning entry points serialize the full 329 329 + // proto response (every generated type derives `serde::Serialize`), so callers 330 330 + // can `JSON.parse` and use the message structure directly. Unit ops return 331 331 + // `i32` (0 = ok, <0 = error) and don't allocate. 332 332 + 333 333 + /// Returns 0 if the gRPC call resolved Ok, -1 otherwise. 334 334 + fn run_unit<F>(fut: F) -> c_int 335 335 + where 336 336 + F: std::future::Future<Output = Result<(), tonic::Status>>, 337 337 + { 338 338 + match RT.block_on(fut) { 339 339 + Ok(_) => 0, 340 340 + Err(_) => -1, 341 341 + } 342 342 + } 343 343 + 344 344 + /// Returns a heap JSON C string of `value`, or null on serialization failure. 345 345 + fn json_response<T: Serialize>(value: T) -> *mut c_char { 346 346 + match serde_json::to_string(&value) { 347 347 + Ok(s) => CString::new(s) 348 348 + .map(|c| c.into_raw()) 349 349 + .unwrap_or(std::ptr::null_mut()), 350 350 + Err(_) => std::ptr::null_mut(), 351 351 + } 352 352 + } 353 353 + 354 354 + /// Take the inner of a tonic response if Ok, else build an `{ "error": ... }` 355 355 + /// JSON payload. 356 356 + fn unwrap_or_err_string<T: Serialize, E: std::fmt::Display>(res: Result<T, E>) -> *mut c_char { 357 357 + match res { 358 358 + Ok(v) => json_response(v), 359 359 + Err(e) => err_string(e.to_string()), 360 360 + } 361 361 + } 362 362 + 363 363 + /// Helper that maps tonic transport / RPC errors to a printable string. 364 364 + async fn connect_err<T, F: std::future::Future<Output = Result<T, tonic::Status>>>( 365 365 + fut: F, 366 366 + ) -> Result<T, String> { 367 367 + fut.await.map_err(|e| e.to_string()) 368 368 + } 369 369 + 370 370 + /// Boolean → bool conversion via i32 sentinel; 0 = false, anything else = true. 371 371 + fn b(v: c_int) -> bool { 372 372 + v != 0 373 373 + } 374 374 + 375 375 + // ── Playback ──────────────────────────────────────────────────────────────── 376 376 + 377 377 + simple_call!( 378 378 + rb_resume_track, 379 379 + PlaylistServiceClient, 380 380 + resume_track, 381 381 + ResumeTrackRequest { 382 382 + start_index: 0, 383 383 + crc: 0, 384 384 + elapsed: 0, 385 385 + offset: 0, 386 386 + } 387 387 + ); 388 388 + simple_call!( 389 389 + rb_playlist_resume, 390 390 + PlaylistServiceClient, 391 391 + playlist_resume, 392 392 + PlaylistResumeRequest {} 393 393 + ); 394 394 + simple_call!( 395 395 + rb_play_all_tracks, 396 396 + PlaybackServiceClient, 397 397 + play_all_tracks, 398 398 + PlayAllTracksRequest { 399 399 + shuffle: Some(false), 400 400 + position: Some(0), 401 401 + } 402 402 + ); 403 403 + 404 404 + /// # Safety 405 405 + /// `path_ptr` must be a valid NUL-terminated UTF-8 string. 406 406 + #[no_mangle] 407 407 + pub unsafe extern "C" fn rb_play_track(path_ptr: *const c_char) -> c_int { 408 408 + let Some(path) = cstr_to_str(path_ptr) else { 409 409 + return -1; 410 410 + }; 411 411 + let path = path.to_string(); 412 412 + run_unit(async move { 413 413 + let mut c = PlaybackServiceClient::connect(url()) 414 414 + .await 415 415 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 416 416 + c.play_track(PlayTrackRequest { path }).await?; 417 417 + Ok(()) 418 418 + }) 419 419 + } 420 420 + 421 421 + /// # Safety 422 422 + /// `album_id_ptr` must be a valid NUL-terminated UTF-8 string. 423 423 + #[no_mangle] 424 424 + pub unsafe extern "C" fn rb_play_album(album_id_ptr: *const c_char, shuffle: c_int) -> c_int { 425 425 + let Some(album_id) = cstr_to_str(album_id_ptr) else { 426 426 + return -1; 427 427 + }; 428 428 + let album_id = album_id.to_string(); 429 429 + let shuffle = b(shuffle); 430 430 + run_unit(async move { 431 431 + let mut c = PlaybackServiceClient::connect(url()) 432 432 + .await 433 433 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 434 434 + c.play_album(PlayAlbumRequest { 435 435 + album_id, 436 436 + shuffle: Some(shuffle), 437 437 + position: Some(0), 438 438 + }) 439 439 + .await?; 440 440 + Ok(()) 441 441 + }) 442 442 + } 443 443 + 444 444 + /// # Safety 445 445 + /// `artist_id_ptr` must be a valid NUL-terminated UTF-8 string. 446 446 + #[no_mangle] 447 447 + pub unsafe extern "C" fn rb_play_artist_tracks( 448 448 + artist_id_ptr: *const c_char, 449 449 + shuffle: c_int, 450 450 + ) -> c_int { 451 451 + let Some(artist_id) = cstr_to_str(artist_id_ptr) else { 452 452 + return -1; 453 453 + }; 454 454 + let artist_id = artist_id.to_string(); 455 455 + let shuffle = b(shuffle); 456 456 + run_unit(async move { 457 457 + let mut c = PlaybackServiceClient::connect(url()) 458 458 + .await 459 459 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 460 460 + c.play_artist_tracks(PlayArtistTracksRequest { 461 461 + artist_id, 462 462 + shuffle: Some(shuffle), 463 463 + position: Some(0), 464 464 + }) 465 465 + .await?; 466 466 + Ok(()) 467 467 + }) 468 468 + } 469 469 + 470 470 + /// # Safety 471 471 + /// `path_ptr` must be a valid NUL-terminated UTF-8 string. 472 472 + #[no_mangle] 473 473 + pub unsafe extern "C" fn rb_play_directory( 474 474 + path_ptr: *const c_char, 475 475 + shuffle: c_int, 476 476 + position: c_int, 477 477 + ) -> c_int { 478 478 + let Some(path) = cstr_to_str(path_ptr) else { 479 479 + return -1; 480 480 + }; 481 481 + let path = path.to_string(); 482 482 + let shuffle = b(shuffle); 483 483 + let pos = if position < 0 { None } else { Some(position) }; 484 484 + run_unit(async move { 485 485 + let mut c = PlaybackServiceClient::connect(url()) 486 486 + .await 487 487 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 488 488 + c.play_directory(PlayDirectoryRequest { 489 489 + path, 490 490 + shuffle: Some(shuffle), 491 491 + recurse: Some(true), 492 492 + position: pos, 493 493 + }) 494 494 + .await?; 495 495 + Ok(()) 496 496 + }) 497 497 + } 498 498 + 499 499 + // ── Playlist (queue) ──────────────────────────────────────────────────────── 500 500 + 501 501 + /// Jump to a queue position (calls `Start { start_index: pos }`). 502 502 + #[no_mangle] 503 503 + pub extern "C" fn rb_jump_to_queue_position(pos: c_int) -> c_int { 504 504 + run_unit(async move { 505 505 + let mut c = PlaylistServiceClient::connect(url()) 506 506 + .await 507 507 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 508 508 + c.start(StartRequest { 509 509 + start_index: Some(pos), 510 510 + elapsed: Some(0), 511 511 + offset: Some(0), 512 512 + }) 513 513 + .await?; 514 514 + Ok(()) 515 515 + }) 516 516 + } 517 517 + 518 518 + simple_call!( 519 519 + rb_shuffle_playlist, 520 520 + PlaylistServiceClient, 521 521 + shuffle_playlist, 522 522 + ShufflePlaylistRequest { start_index: 0 } 523 523 + ); 524 524 + 525 525 + /// `paths_json` must be a JSON array of strings. 526 526 + /// `position` follows the rockbox INSERT_* constants. 527 527 + /// 528 528 + /// # Safety 529 529 + /// `paths_json_ptr` must be a valid NUL-terminated UTF-8 string. 530 530 + #[no_mangle] 531 531 + pub unsafe extern "C" fn rb_insert_tracks( 532 532 + paths_json_ptr: *const c_char, 533 533 + position: c_int, 534 534 + shuffle: c_int, 535 535 + ) -> c_int { 536 536 + let Some(paths_json) = cstr_to_str(paths_json_ptr) else { 537 537 + return -1; 538 538 + }; 539 539 + let Ok(paths) = serde_json::from_str::<Vec<String>>(paths_json) else { 540 540 + return -2; 541 541 + }; 542 542 + let shuffle = b(shuffle); 543 543 + run_unit(async move { 544 544 + let mut c = PlaylistServiceClient::connect(url()) 545 545 + .await 546 546 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 547 547 + c.insert_tracks(InsertTracksRequest { 548 548 + playlist_id: None, 549 549 + position, 550 550 + tracks: paths, 551 551 + shuffle: Some(shuffle), 552 552 + }) 553 553 + .await?; 554 554 + Ok(()) 555 555 + }) 556 556 + } 557 557 + 558 558 + /// Convenience: insert a single track at position INSERT_FIRST (-4). 559 559 + /// 560 560 + /// # Safety 561 561 + /// `path_ptr` must be a valid NUL-terminated UTF-8 string. 562 562 + #[no_mangle] 563 563 + pub unsafe extern "C" fn rb_insert_track_next(path_ptr: *const c_char) -> c_int { 564 564 + let Some(p) = cstr_to_str(path_ptr) else { 565 565 + return -1; 566 566 + }; 567 567 + let path = p.to_string(); 568 568 + run_unit(async move { 569 569 + let mut c = PlaylistServiceClient::connect(url()) 570 570 + .await 571 571 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 572 572 + c.insert_tracks(InsertTracksRequest { 573 573 + playlist_id: None, 574 574 + position: -4, // INSERT_FIRST 575 575 + tracks: vec![path], 576 576 + shuffle: Some(false), 577 577 + }) 578 578 + .await?; 579 579 + Ok(()) 580 580 + }) 581 581 + } 582 582 + 583 583 + /// Convenience: insert a single track at position INSERT_LAST (-3). 584 584 + /// 585 585 + /// # Safety 586 586 + /// `path_ptr` must be a valid NUL-terminated UTF-8 string. 587 587 + #[no_mangle] 588 588 + pub unsafe extern "C" fn rb_insert_track_last(path_ptr: *const c_char) -> c_int { 589 589 + let Some(p) = cstr_to_str(path_ptr) else { 590 590 + return -1; 591 591 + }; 592 592 + let path = p.to_string(); 593 593 + run_unit(async move { 594 594 + let mut c = PlaylistServiceClient::connect(url()) 595 595 + .await 596 596 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 597 597 + c.insert_tracks(InsertTracksRequest { 598 598 + playlist_id: None, 599 599 + position: -3, // INSERT_LAST 600 600 + tracks: vec![path], 601 601 + shuffle: Some(false), 602 602 + }) 603 603 + .await?; 604 604 + Ok(()) 605 605 + }) 606 606 + } 607 607 + 608 608 + /// # Safety 609 609 + /// `path_ptr` must be a valid NUL-terminated UTF-8 string. 610 610 + #[no_mangle] 611 611 + pub unsafe extern "C" fn rb_insert_directory(path_ptr: *const c_char, position: c_int) -> c_int { 612 612 + let Some(p) = cstr_to_str(path_ptr) else { 613 613 + return -1; 614 614 + }; 615 615 + let directory = p.to_string(); 616 616 + run_unit(async move { 617 617 + let mut c = PlaylistServiceClient::connect(url()) 618 618 + .await 619 619 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 620 620 + c.insert_directory(InsertDirectoryRequest { 621 621 + playlist_id: None, 622 622 + position, 623 623 + directory, 624 624 + recurse: Some(true), 625 625 + shuffle: Some(false), 626 626 + }) 627 627 + .await?; 628 628 + Ok(()) 629 629 + }) 630 630 + } 631 631 + 632 632 + #[no_mangle] 633 633 + pub extern "C" fn rb_remove_from_queue(position: c_int) -> c_int { 634 634 + run_unit(async move { 635 635 + let mut c = PlaylistServiceClient::connect(url()) 636 636 + .await 637 637 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 638 638 + c.remove_tracks(RemoveTracksRequest { 639 639 + positions: vec![position], 640 640 + }) 641 641 + .await?; 642 642 + Ok(()) 643 643 + }) 644 644 + } 645 645 + 646 646 + /// JSON snapshot of `PlaylistService::GetCurrent` (queue position + tracks). 647 647 + #[no_mangle] 648 648 + pub extern "C" fn rb_get_playlist_current_json() -> *mut c_char { 649 649 + let res = RT.block_on(async { 650 650 + let mut c = PlaylistServiceClient::connect(url()) 651 651 + .await 652 652 + .map_err(|e| e.to_string())?; 653 653 + connect_err(c.get_current(GetCurrentRequest {})).await 654 654 + }); 655 655 + unwrap_or_err_string(res.map(|r| r.into_inner())) 656 656 + } 657 657 + 658 658 + // ── Library ───────────────────────────────────────────────────────────────── 659 659 + 660 660 + #[no_mangle] 661 661 + pub extern "C" fn rb_get_tracks_json() -> *mut c_char { 662 662 + let res = RT.block_on(async { 663 663 + let mut c = LibraryServiceClient::connect(url()) 664 664 + .await 665 665 + .map_err(|e| e.to_string())?; 666 666 + connect_err(c.get_tracks(GetTracksRequest {})).await 667 667 + }); 668 668 + unwrap_or_err_string(res.map(|r| r.into_inner())) 669 669 + } 670 670 + 671 671 + #[no_mangle] 672 672 + pub extern "C" fn rb_get_artists_json() -> *mut c_char { 673 673 + let res = RT.block_on(async { 674 674 + let mut c = LibraryServiceClient::connect(url()) 675 675 + .await 676 676 + .map_err(|e| e.to_string())?; 677 677 + connect_err(c.get_artists(GetArtistsRequest {})).await 678 678 + }); 679 679 + unwrap_or_err_string(res.map(|r| r.into_inner())) 680 680 + } 681 681 + 682 682 + /// # Safety 683 683 + /// `id_ptr` must be a valid NUL-terminated UTF-8 string. 684 684 + #[no_mangle] 685 685 + pub unsafe extern "C" fn rb_get_album_json(id_ptr: *const c_char) -> *mut c_char { 686 686 + let Some(id) = cstr_to_str(id_ptr) else { 687 687 + return err_string("missing id"); 688 688 + }; 689 689 + let id = id.to_string(); 690 690 + let res = RT.block_on(async { 691 691 + let mut c = LibraryServiceClient::connect(url()) 692 692 + .await 693 693 + .map_err(|e| e.to_string())?; 694 694 + connect_err(c.get_album(GetAlbumRequest { id })).await 695 695 + }); 696 696 + unwrap_or_err_string(res.map(|r| r.into_inner())) 697 697 + } 698 698 + 699 699 + #[no_mangle] 700 700 + pub extern "C" fn rb_get_liked_tracks_json() -> *mut c_char { 701 701 + let res = RT.block_on(async { 702 702 + let mut c = LibraryServiceClient::connect(url()) 703 703 + .await 704 704 + .map_err(|e| e.to_string())?; 705 705 + connect_err(c.get_liked_tracks(GetLikedTracksRequest {})).await 706 706 + }); 707 707 + unwrap_or_err_string(res.map(|r| r.into_inner())) 708 708 + } 709 709 + 710 710 + /// # Safety 711 711 + /// `term_ptr` must be a valid NUL-terminated UTF-8 string. 712 712 + #[no_mangle] 713 713 + pub unsafe extern "C" fn rb_search_json(term_ptr: *const c_char) -> *mut c_char { 714 714 + let Some(term) = cstr_to_str(term_ptr) else { 715 715 + return err_string("missing term"); 716 716 + }; 717 717 + let term = term.to_string(); 718 718 + let res = RT.block_on(async { 719 719 + let mut c = LibraryServiceClient::connect(url()) 720 720 + .await 721 721 + .map_err(|e| e.to_string())?; 722 722 + connect_err(c.search(SearchRequest { term })).await 723 723 + }); 724 724 + unwrap_or_err_string(res.map(|r| r.into_inner())) 725 725 + } 726 726 + 727 727 + // ── Sound ─────────────────────────────────────────────────────────────────── 728 728 + 729 729 + #[no_mangle] 730 730 + pub extern "C" fn rb_adjust_volume(steps: c_int) -> c_int { 731 731 + run_unit(async move { 732 732 + let mut c = SoundServiceClient::connect(url()) 733 733 + .await 734 734 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 735 735 + c.adjust_volume(AdjustVolumeRequest { steps }).await?; 736 736 + Ok(()) 737 737 + }) 738 738 + } 739 739 + 740 740 + /// `setting` follows the rockbox SOUND_* enum (0 = volume, etc.). 741 741 + #[no_mangle] 742 742 + pub extern "C" fn rb_sound_current_json(setting: c_int) -> *mut c_char { 743 743 + let res = RT.block_on(async { 744 744 + let mut c = SoundServiceClient::connect(url()) 745 745 + .await 746 746 + .map_err(|e| e.to_string())?; 747 747 + connect_err(c.sound_current(SoundCurrentRequest { setting })).await 748 748 + }); 749 749 + unwrap_or_err_string(res.map(|r| r.into_inner())) 750 750 + } 751 751 + 752 752 + // ── Settings ──────────────────────────────────────────────────────────────── 753 753 + 754 754 + #[no_mangle] 755 755 + pub extern "C" fn rb_save_shuffle(enabled: c_int) -> c_int { 756 756 + let enabled = b(enabled); 757 757 + run_unit(async move { 758 758 + let mut c = SettingsServiceClient::connect(url()) 759 759 + .await 760 760 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 761 761 + c.save_settings(SaveSettingsRequest { 762 762 + playlist_shuffle: Some(enabled), 763 763 + ..Default::default() 764 764 + }) 765 765 + .await?; 766 766 + Ok(()) 767 767 + }) 768 768 + } 769 769 + 770 770 + #[no_mangle] 771 771 + pub extern "C" fn rb_save_repeat(repeat_mode: c_int) -> c_int { 772 772 + run_unit(async move { 773 773 + let mut c = SettingsServiceClient::connect(url()) 774 774 + .await 775 775 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 776 776 + c.save_settings(SaveSettingsRequest { 777 777 + repeat_mode: Some(repeat_mode), 778 778 + ..Default::default() 779 779 + }) 780 780 + .await?; 781 781 + Ok(()) 782 782 + }) 783 783 + } 784 784 + 785 785 + #[no_mangle] 786 786 + pub extern "C" fn rb_get_global_settings_json() -> *mut c_char { 787 787 + let res = RT.block_on(async { 788 788 + let mut c = SettingsServiceClient::connect(url()) 789 789 + .await 790 790 + .map_err(|e| e.to_string())?; 791 791 + connect_err(c.get_global_settings(GetGlobalSettingsRequest {})).await 792 792 + }); 793 793 + unwrap_or_err_string(res.map(|r| r.into_inner())) 794 794 + } 795 795 + 796 796 + // ── System ────────────────────────────────────────────────────────────────── 797 797 + 798 798 + #[no_mangle] 799 799 + pub extern "C" fn rb_get_global_status_json() -> *mut c_char { 800 800 + let res = RT.block_on(async { 801 801 + let mut c = SystemServiceClient::connect(url()) 802 802 + .await 803 803 + .map_err(|e| e.to_string())?; 804 804 + connect_err(c.get_global_status(GetGlobalStatusRequest {})).await 805 805 + }); 806 806 + unwrap_or_err_string(res.map(|r| r.into_inner())) 807 807 + } 808 808 + 809 809 + // ── Browse ────────────────────────────────────────────────────────────────── 810 810 + 811 811 + /// `path_ptr` may be null to fetch the music root. 812 812 + /// 813 813 + /// # Safety 814 814 + /// If non-null, `path_ptr` must be a valid NUL-terminated UTF-8 string. 815 815 + #[no_mangle] 816 816 + pub unsafe extern "C" fn rb_tree_get_entries_json(path_ptr: *const c_char) -> *mut c_char { 817 817 + let path = if path_ptr.is_null() { 818 818 + None 819 819 + } else { 820 820 + cstr_to_str(path_ptr).map(|s| s.to_string()) 821 821 + }; 822 822 + let res = RT.block_on(async { 823 823 + let mut c = BrowseServiceClient::connect(url()) 824 824 + .await 825 825 + .map_err(|e| e.to_string())?; 826 826 + connect_err(c.tree_get_entries(TreeGetEntriesRequest { path })).await 827 827 + }); 828 828 + unwrap_or_err_string(res.map(|r| r.into_inner())) 829 829 + } 830 830 + 831 831 + // ── Saved playlists ───────────────────────────────────────────────────────── 832 832 + 833 833 + #[no_mangle] 834 834 + pub extern "C" fn rb_get_saved_playlists_json() -> *mut c_char { 835 835 + let res = RT.block_on(async { 836 836 + let mut c = SavedPlaylistServiceClient::connect(url()) 837 837 + .await 838 838 + .map_err(|e| e.to_string())?; 839 839 + connect_err(c.get_saved_playlists(GetSavedPlaylistsRequest { folder_id: None })).await 840 840 + }); 841 841 + unwrap_or_err_string(res.map(|r| r.into_inner())) 842 842 + } 843 843 + 844 844 + /// # Safety 845 845 + /// `name_ptr` must be a valid UTF-8 NUL-terminated string. `description_ptr` 846 846 + /// may be null. `track_ids_json_ptr` must be a JSON array of strings (may be 847 847 + /// `[]` for an empty playlist). 848 848 + #[no_mangle] 849 849 + pub unsafe extern "C" fn rb_create_saved_playlist( 850 850 + name_ptr: *const c_char, 851 851 + description_ptr: *const c_char, 852 852 + track_ids_json_ptr: *const c_char, 853 853 + ) -> c_int { 854 854 + let Some(name) = cstr_to_str(name_ptr) else { 855 855 + return -1; 856 856 + }; 857 857 + let name = name.to_string(); 858 858 + let description = if description_ptr.is_null() { 859 859 + None 860 860 + } else { 861 861 + cstr_to_str(description_ptr).map(|s| s.to_string()) 862 862 + }; 863 863 + let track_ids: Vec<String> = if track_ids_json_ptr.is_null() { 864 864 + Vec::new() 865 865 + } else { 866 866 + let Some(s) = cstr_to_str(track_ids_json_ptr) else { 867 867 + return -2; 868 868 + }; 869 869 + match serde_json::from_str(s) { 870 870 + Ok(v) => v, 871 871 + Err(_) => return -3, 872 872 + } 873 873 + }; 874 874 + run_unit(async move { 875 875 + let mut c = SavedPlaylistServiceClient::connect(url()) 876 876 + .await 877 877 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 878 878 + c.create_saved_playlist(CreateSavedPlaylistRequest { 879 879 + name, 880 880 + description, 881 881 + image: None, 882 882 + folder_id: None, 883 883 + track_ids, 884 884 + }) 885 885 + .await?; 886 886 + Ok(()) 887 887 + }) 888 888 + } 889 889 + 890 890 + /// # Safety 891 891 + /// `id_ptr` and `name_ptr` must be valid UTF-8 NUL-terminated strings. 892 892 + /// `description_ptr` may be null. 893 893 + #[no_mangle] 894 894 + pub unsafe extern "C" fn rb_update_saved_playlist( 895 895 + id_ptr: *const c_char, 896 896 + name_ptr: *const c_char, 897 897 + description_ptr: *const c_char, 898 898 + ) -> c_int { 899 899 + let Some(id) = cstr_to_str(id_ptr) else { 900 900 + return -1; 901 901 + }; 902 902 + let Some(name) = cstr_to_str(name_ptr) else { 903 903 + return -1; 904 904 + }; 905 905 + let id = id.to_string(); 906 906 + let name = name.to_string(); 907 907 + let description = if description_ptr.is_null() { 908 908 + None 909 909 + } else { 910 910 + cstr_to_str(description_ptr).map(|s| s.to_string()) 911 911 + }; 912 912 + run_unit(async move { 913 913 + let mut c = SavedPlaylistServiceClient::connect(url()) 914 914 + .await 915 915 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 916 916 + c.update_saved_playlist(UpdateSavedPlaylistRequest { 917 917 + id, 918 918 + name, 919 919 + description, 920 920 + image: None, 921 921 + folder_id: None, 922 922 + }) 923 923 + .await?; 924 924 + Ok(()) 925 925 + }) 926 926 + } 927 927 + 928 928 + /// # Safety 929 929 + /// `id_ptr` must be a valid NUL-terminated UTF-8 string. 930 930 + #[no_mangle] 931 931 + pub unsafe extern "C" fn rb_delete_saved_playlist(id_ptr: *const c_char) -> c_int { 932 932 + let Some(id) = cstr_to_str(id_ptr) else { 933 933 + return -1; 934 934 + }; 935 935 + let id = id.to_string(); 936 936 + run_unit(async move { 937 937 + let mut c = SavedPlaylistServiceClient::connect(url()) 938 938 + .await 939 939 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 940 940 + c.delete_saved_playlist(DeleteSavedPlaylistRequest { id }) 941 941 + .await?; 942 942 + Ok(()) 943 943 + }) 944 944 + } 945 945 + 946 946 + /// # Safety 947 947 + /// Both pointers must be valid NUL-terminated UTF-8 strings. 948 948 + #[no_mangle] 949 949 + pub unsafe extern "C" fn rb_add_track_to_playlist( 950 950 + playlist_id_ptr: *const c_char, 951 951 + track_id_ptr: *const c_char, 952 952 + ) -> c_int { 953 953 + let Some(playlist_id) = cstr_to_str(playlist_id_ptr) else { 954 954 + return -1; 955 955 + }; 956 956 + let Some(track_id) = cstr_to_str(track_id_ptr) else { 957 957 + return -1; 958 958 + }; 959 959 + let playlist_id = playlist_id.to_string(); 960 960 + let track_id = track_id.to_string(); 961 961 + run_unit(async move { 962 962 + let mut c = SavedPlaylistServiceClient::connect(url()) 963 963 + .await 964 964 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 965 965 + c.add_tracks_to_saved_playlist(AddTracksToSavedPlaylistRequest { 966 966 + playlist_id, 967 967 + track_ids: vec![track_id], 968 968 + }) 969 969 + .await?; 970 970 + Ok(()) 971 971 + }) 972 972 + } 973 973 + 974 974 + /// # Safety 975 975 + /// Both pointers must be valid NUL-terminated UTF-8 strings. 976 976 + #[no_mangle] 977 977 + pub unsafe extern "C" fn rb_remove_track_from_playlist( 978 978 + playlist_id_ptr: *const c_char, 979 979 + track_id_ptr: *const c_char, 980 980 + ) -> c_int { 981 981 + let Some(playlist_id) = cstr_to_str(playlist_id_ptr) else { 982 982 + return -1; 983 983 + }; 984 984 + let Some(track_id) = cstr_to_str(track_id_ptr) else { 985 985 + return -1; 986 986 + }; 987 987 + let playlist_id = playlist_id.to_string(); 988 988 + let track_id = track_id.to_string(); 989 989 + run_unit(async move { 990 990 + let mut c = SavedPlaylistServiceClient::connect(url()) 991 991 + .await 992 992 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 993 993 + c.remove_track_from_saved_playlist(RemoveTrackFromSavedPlaylistRequest { 994 994 + playlist_id, 995 995 + track_id, 996 996 + }) 997 997 + .await?; 998 998 + Ok(()) 999 999 + }) 1000 1000 + } 1001 1001 + 1002 1002 + /// # Safety 1003 1003 + /// `id_ptr` must be a valid NUL-terminated UTF-8 string. 1004 1004 + #[no_mangle] 1005 1005 + pub unsafe extern "C" fn rb_get_saved_playlist_tracks_json(id_ptr: *const c_char) -> *mut c_char { 1006 1006 + let Some(id) = cstr_to_str(id_ptr) else { 1007 1007 + return err_string("missing id"); 1008 1008 + }; 1009 1009 + let playlist_id = id.to_string(); 1010 1010 + let res = RT.block_on(async { 1011 1011 + let mut c = SavedPlaylistServiceClient::connect(url()) 1012 1012 + .await 1013 1013 + .map_err(|e| e.to_string())?; 1014 1014 + connect_err(c.get_saved_playlist_tracks(GetSavedPlaylistTracksRequest { playlist_id })) 1015 1015 + .await 1016 1016 + }); 1017 1017 + unwrap_or_err_string(res.map(|r| r.into_inner())) 1018 1018 + } 1019 1019 + 1020 1020 + /// # Safety 1021 1021 + /// `id_ptr` must be a valid NUL-terminated UTF-8 string. 1022 1022 + #[no_mangle] 1023 1023 + pub unsafe extern "C" fn rb_play_saved_playlist(id_ptr: *const c_char) -> c_int { 1024 1024 + let Some(playlist_id) = cstr_to_str(id_ptr) else { 1025 1025 + return -1; 1026 1026 + }; 1027 1027 + let playlist_id = playlist_id.to_string(); 1028 1028 + run_unit(async move { 1029 1029 + let mut c = SavedPlaylistServiceClient::connect(url()) 1030 1030 + .await 1031 1031 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 1032 1032 + c.play_saved_playlist(PlaySavedPlaylistRequest { playlist_id }) 1033 1033 + .await?; 1034 1034 + Ok(()) 1035 1035 + }) 1036 1036 + } 1037 1037 + 1038 1038 + // ── Smart playlists ───────────────────────────────────────────────────────── 1039 1039 + 1040 1040 + #[no_mangle] 1041 1041 + pub extern "C" fn rb_get_smart_playlists_json() -> *mut c_char { 1042 1042 + let res = RT.block_on(async { 1043 1043 + let mut c = SmartPlaylistServiceClient::connect(url()) 1044 1044 + .await 1045 1045 + .map_err(|e| e.to_string())?; 1046 1046 + connect_err(c.get_smart_playlists(GetSmartPlaylistsRequest {})).await 1047 1047 + }); 1048 1048 + unwrap_or_err_string(res.map(|r| r.into_inner())) 1049 1049 + } 1050 1050 + 1051 1051 + /// # Safety 1052 1052 + /// `id_ptr` must be a valid NUL-terminated UTF-8 string. 1053 1053 + #[no_mangle] 1054 1054 + pub unsafe extern "C" fn rb_get_smart_playlist_tracks_json(id_ptr: *const c_char) -> *mut c_char { 1055 1055 + let Some(id_s) = cstr_to_str(id_ptr) else { 1056 1056 + return err_string("missing id"); 1057 1057 + }; 1058 1058 + let id = id_s.to_string(); 1059 1059 + let res = RT.block_on(async { 1060 1060 + let mut c = SmartPlaylistServiceClient::connect(url()) 1061 1061 + .await 1062 1062 + .map_err(|e| e.to_string())?; 1063 1063 + connect_err(c.get_smart_playlist_tracks(GetSmartPlaylistTracksRequest { id })).await 1064 1064 + }); 1065 1065 + unwrap_or_err_string(res.map(|r| r.into_inner())) 1066 1066 + } 1067 1067 + 1068 1068 + /// # Safety 1069 1069 + /// `id_ptr` must be a valid NUL-terminated UTF-8 string. 1070 1070 + #[no_mangle] 1071 1071 + pub unsafe extern "C" fn rb_play_smart_playlist(id_ptr: *const c_char) -> c_int { 1072 1072 + let Some(id_s) = cstr_to_str(id_ptr) else { 1073 1073 + return -1; 1074 1074 + }; 1075 1075 + let id = id_s.to_string(); 1076 1076 + run_unit(async move { 1077 1077 + let mut c = SmartPlaylistServiceClient::connect(url()) 1078 1078 + .await 1079 1079 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 1080 1080 + c.play_smart_playlist(PlaySmartPlaylistRequest { id }) 1081 1081 + .await?; 1082 1082 + Ok(()) 1083 1083 + }) 1084 1084 + } 1085 1085 + 1086 1086 + // ── Bluetooth ─────────────────────────────────────────────────────────────── 1087 1087 + 1088 1088 + /// 1 if the Bluetooth service is reachable and answers GetDevices, 0 otherwise. 1089 1089 + #[no_mangle] 1090 1090 + pub extern "C" fn rb_bluetooth_available() -> c_int { 1091 1091 + let ok = RT.block_on(async { 1092 1092 + let Ok(mut c) = BluetoothServiceClient::connect(url()).await else { 1093 1093 + return false; 1094 1094 + }; 1095 1095 + c.get_devices(GetBluetoothDevicesRequest {}).await.is_ok() 1096 1096 + }); 1097 1097 + if ok { 1098 1098 + 1 1099 1099 + } else { 1100 1100 + 0 1101 1101 + } 1102 1102 + } 1103 1103 + 1104 1104 + #[no_mangle] 1105 1105 + pub extern "C" fn rb_get_bluetooth_devices_json() -> *mut c_char { 1106 1106 + let res = RT.block_on(async { 1107 1107 + let mut c = BluetoothServiceClient::connect(url()) 1108 1108 + .await 1109 1109 + .map_err(|e| e.to_string())?; 1110 1110 + connect_err(c.get_devices(GetBluetoothDevicesRequest {})).await 1111 1111 + }); 1112 1112 + unwrap_or_err_string(res.map(|r| r.into_inner())) 1113 1113 + } 1114 1114 + 1115 1115 + /// # Safety 1116 1116 + /// `addr_ptr` must be a valid NUL-terminated UTF-8 string. 1117 1117 + #[no_mangle] 1118 1118 + pub unsafe extern "C" fn rb_connect_bluetooth(addr_ptr: *const c_char) -> c_int { 1119 1119 + let Some(s) = cstr_to_str(addr_ptr) else { 1120 1120 + return -1; 1121 1121 + }; 1122 1122 + let address = s.to_string(); 1123 1123 + run_unit(async move { 1124 1124 + let mut c = BluetoothServiceClient::connect(url()) 1125 1125 + .await 1126 1126 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 1127 1127 + c.connect_device(ConnectBluetoothDeviceRequest { address }) 1128 1128 + .await?; 1129 1129 + Ok(()) 1130 1130 + }) 1131 1131 + } 1132 1132 + 1133 1133 + /// # Safety 1134 1134 + /// `addr_ptr` must be a valid NUL-terminated UTF-8 string. 1135 1135 + #[no_mangle] 1136 1136 + pub unsafe extern "C" fn rb_disconnect_bluetooth(addr_ptr: *const c_char) -> c_int { 1137 1137 + let Some(s) = cstr_to_str(addr_ptr) else { 1138 1138 + return -1; 1139 1139 + }; 1140 1140 + let address = s.to_string(); 1141 1141 + run_unit(async move { 1142 1142 + let mut c = BluetoothServiceClient::connect(url()) 1143 1143 + .await 1144 1144 + .map_err(|e| tonic::Status::unavailable(e.to_string()))?; 1145 1145 + c.disconnect(DisconnectBluetoothDeviceRequest { address }) 1146 1146 + .await?; 1147 1147 + Ok(()) 1148 1148 + }) 1149 1149 + } 1150 1150 + 1151 1151 + // ── Streaming subscriptions ───────────────────────────────────────────────── 1152 1152 + // 1153 1153 + // Pattern (Option B from the design discussion): each `rb_subscribe_*` spawns 1154 1154 + // a tonic streaming RPC on the runtime, drains it into a bounded mpsc, and 1155 1155 + // returns an `i32` subscription id. Platform code (Swift / Kotlin) drives a 1156 1156 + // background loop calling `rb_poll_event(id, timeout_ms)`, which blocks up to 1157 1157 + // `timeout_ms` waiting for the next JSON payload, returns it as a heap 1158 1158 + // C string (free with `rb_free_string`), or returns null on timeout / closed 1159 1159 + // stream. `rb_unsubscribe` aborts the task and removes the entry. 1160 1160 + 1161 1161 + const EVENT_BUFFER: usize = 64; 1162 1162 + 1163 1163 + struct Subscription { 1164 1164 + rx: mpsc::Receiver<String>, 1165 1165 + abort: AbortHandle, 1166 1166 + } 1167 1167 + 1168 1168 + static SUBS: Lazy<RwLock<HashMap<i32, Subscription>>> = Lazy::new(|| RwLock::new(HashMap::new())); 1169 1169 + static NEXT_SUB_ID: AtomicI32 = AtomicI32::new(1); 1170 1170 + 1171 1171 + #[derive(Serialize)] 1172 1172 + struct StreamErrorJson { 1173 1173 + error: String, 1174 1174 + } 1175 1175 + 1176 1176 + fn next_sub_id() -> i32 { 1177 1177 + NEXT_SUB_ID.fetch_add(1, Ordering::SeqCst) 1178 1178 + } 1179 1179 + 1180 1180 + fn register_sub(rx: mpsc::Receiver<String>, abort: AbortHandle) -> i32 { 1181 1181 + let id = next_sub_id(); 1182 1182 + if let Ok(mut map) = SUBS.write() { 1183 1183 + map.insert(id, Subscription { rx, abort }); 1184 1184 + } 1185 1185 + id 1186 1186 + } 1187 1187 + 1188 1188 + /// Spawns `task_factory` on the runtime, where it should drain a tonic stream 1189 1189 + /// into the supplied sender. Returns the subscription id. 1190 1190 + fn spawn_stream<F, Fut>(task_factory: F) -> i32 1191 1191 + where 1192 1192 + F: FnOnce(mpsc::Sender<String>) -> Fut + Send + 'static, 1193 1193 + Fut: std::future::Future<Output = ()> + Send + 'static, 1194 1194 + { 1195 1195 + let (tx, rx) = mpsc::channel::<String>(EVENT_BUFFER); 1196 1196 + let handle = RT.spawn(async move { 1197 1197 + task_factory(tx).await; 1198 1198 + }); 1199 1199 + register_sub(rx, handle.abort_handle()) 1200 1200 + } 1201 1201 + 1202 1202 + /// Subscribes to `PlaybackService::StreamStatus`. Each event is a JSON 1203 1203 + /// `{ "status": <int> }` payload (mirrors `rb_status_json`). 1204 1204 + #[no_mangle] 1205 1205 + pub extern "C" fn rb_subscribe_status() -> c_int { 1206 1206 + let server_url = url(); 1207 1207 + spawn_stream(move |tx| async move { 1208 1208 + match PlaybackServiceClient::connect(server_url).await { 1209 1209 + Ok(mut c) => match c.stream_status(StreamStatusRequest {}).await { 1210 1210 + Ok(resp) => { 1211 1211 + let mut s = resp.into_inner(); 1212 1212 + while let Ok(Some(msg)) = s.message().await { 1213 1213 + let payload = serde_json::to_string(&StatusJson { status: msg.status }) 1214 1214 + .unwrap_or_else(|_| "{}".into()); 1215 1215 + if tx.send(payload).await.is_err() { 1216 1216 + break; 1217 1217 + } 1218 1218 + } 1219 1219 + } 1220 1220 + Err(e) => { 1221 1221 + let _ = tx 1222 1222 + .send( 1223 1223 + serde_json::to_string(&StreamErrorJson { 1224 1224 + error: format!("stream_status: {e}"), 1225 1225 + }) 1226 1226 + .unwrap_or_default(), 1227 1227 + ) 1228 1228 + .await; 1229 1229 + } 1230 1230 + }, 1231 1231 + Err(e) => { 1232 1232 + let _ = tx 1233 1233 + .send( 1234 1234 + serde_json::to_string(&StreamErrorJson { 1235 1235 + error: format!("connect: {e}"), 1236 1236 + }) 1237 1237 + .unwrap_or_default(), 1238 1238 + ) 1239 1239 + .await; 1240 1240 + } 1241 1241 + } 1242 1242 + }) 1243 1243 + } 1244 1244 + 1245 1245 + /// Subscribes to `PlaybackService::StreamCurrentTrack`. Each event JSON 1246 1246 + /// matches the `rb_current_track_json` shape. 1247 1247 + #[no_mangle] 1248 1248 + pub extern "C" fn rb_subscribe_current_track() -> c_int { 1249 1249 + let server_url = url(); 1250 1250 + spawn_stream(move |tx| async move { 1251 1251 + match PlaybackServiceClient::connect(server_url).await { 1252 1252 + Ok(mut c) => match c.stream_current_track(StreamCurrentTrackRequest {}).await { 1253 1253 + Ok(resp) => { 1254 1254 + let mut s = resp.into_inner(); 1255 1255 + while let Ok(Some(msg)) = s.message().await { 1256 1256 + let payload = serde_json::to_string(&TrackJson { 1257 1257 + id: msg.id, 1258 1258 + path: msg.path, 1259 1259 + title: msg.title, 1260 1260 + artist: msg.artist, 1261 1261 + album: msg.album, 1262 1262 + album_art: msg.album_art.filter(|a| !a.is_empty()), 1263 1263 + duration_ms: msg.length as i64, 1264 1264 + elapsed_ms: msg.elapsed as i64, 1265 1265 + }) 1266 1266 + .unwrap_or_else(|_| "{}".into()); 1267 1267 + if tx.send(payload).await.is_err() { 1268 1268 + break; 1269 1269 + } 1270 1270 + } 1271 1271 + } 1272 1272 + Err(e) => { 1273 1273 + let _ = tx 1274 1274 + .send( 1275 1275 + serde_json::to_string(&StreamErrorJson { 1276 1276 + error: format!("stream_current_track: {e}"), 1277 1277 + }) 1278 1278 + .unwrap_or_default(), 1279 1279 + ) 1280 1280 + .await; 1281 1281 + } 1282 1282 + }, 1283 1283 + Err(e) => { 1284 1284 + let _ = tx 1285 1285 + .send( 1286 1286 + serde_json::to_string(&StreamErrorJson { 1287 1287 + error: format!("connect: {e}"), 1288 1288 + }) 1289 1289 + .unwrap_or_default(), 1290 1290 + ) 1291 1291 + .await; 1292 1292 + } 1293 1293 + } 1294 1294 + }) 1295 1295 + } 1296 1296 + 1297 1297 + #[derive(Serialize)] 1298 1298 + struct PlaylistEventJson { 1299 1299 + index: i32, 1300 1300 + amount: i32, 1301 1301 + tracks: Vec<TrackJson>, 1302 1302 + } 1303 1303 + 1304 1304 + /// Subscribes to `PlaybackService::StreamPlaylist`. Each event is a JSON 1305 1305 + /// `{ index, amount, tracks: [...] }` snapshot of the queue. 1306 1306 + #[no_mangle] 1307 1307 + pub extern "C" fn rb_subscribe_playlist() -> c_int { 1308 1308 + let server_url = url(); 1309 1309 + spawn_stream(move |tx| async move { 1310 1310 + match PlaybackServiceClient::connect(server_url).await { 1311 1311 + Ok(mut c) => match c.stream_playlist(StreamPlaylistRequest {}).await { 1312 1312 + Ok(resp) => { 1313 1313 + let mut s = resp.into_inner(); 1314 1314 + while let Ok(Some(msg)) = s.message().await { 1315 1315 + let tracks: Vec<TrackJson> = msg 1316 1316 + .tracks 1317 1317 + .into_iter() 1318 1318 + .map(|t| TrackJson { 1319 1319 + id: t.id, 1320 1320 + path: t.path, 1321 1321 + title: t.title, 1322 1322 + artist: t.artist, 1323 1323 + album: t.album, 1324 1324 + album_art: t.album_art.filter(|a| !a.is_empty()), 1325 1325 + duration_ms: t.length as i64, 1326 1326 + elapsed_ms: t.elapsed as i64, 1327 1327 + }) 1328 1328 + .collect(); 1329 1329 + let payload = serde_json::to_string(&PlaylistEventJson { 1330 1330 + index: msg.index, 1331 1331 + amount: msg.amount, 1332 1332 + tracks, 1333 1333 + }) 1334 1334 + .unwrap_or_else(|_| "{}".into()); 1335 1335 + if tx.send(payload).await.is_err() { 1336 1336 + break; 1337 1337 + } 1338 1338 + } 1339 1339 + } 1340 1340 + Err(e) => { 1341 1341 + let _ = tx 1342 1342 + .send( 1343 1343 + serde_json::to_string(&StreamErrorJson { 1344 1344 + error: format!("stream_playlist: {e}"), 1345 1345 + }) 1346 1346 + .unwrap_or_default(), 1347 1347 + ) 1348 1348 + .await; 1349 1349 + } 1350 1350 + }, 1351 1351 + Err(e) => { 1352 1352 + let _ = tx 1353 1353 + .send( 1354 1354 + serde_json::to_string(&StreamErrorJson { 1355 1355 + error: format!("connect: {e}"), 1356 1356 + }) 1357 1357 + .unwrap_or_default(), 1358 1358 + ) 1359 1359 + .await; 1360 1360 + } 1361 1361 + } 1362 1362 + }) 1363 1363 + } 1364 1364 + 1365 1365 + // ── mDNS / Bonjour discovery ──────────────────────────────────────────────── 1366 1366 + // 1367 1367 + // Wraps the `rockbox-discovery` crate so the mobile app can find rockboxd 1368 1368 + // instances on the local network. Each event is one resolved service: 1369 1369 + // { "name", "fullname", "hostname", "port", "addresses": [...], "properties": {...} } 1370 1370 + // Service names follow Bonjour conventions, e.g. "_rockbox._tcp.local.". 1371 1371 + 1372 1372 + #[derive(Serialize)] 1373 1373 + struct DiscoveryEventJson { 1374 1374 + name: String, 1375 1375 + fullname: String, 1376 1376 + hostname: String, 1377 1377 + port: u16, 1378 1378 + addresses: Vec<String>, 1379 1379 + properties: HashMap<String, String>, 1380 1380 + } 1381 1381 + 1382 1382 + /// Subscribes to mDNS / Bonjour discovery for `service_name` (e.g. the 1383 1383 + /// constants exposed by `rockbox-discovery`: `_rockbox._tcp.local.`, 1384 1384 + /// `_googlecast._tcp.local.`, etc.). Each resolved service triggers one 1385 1385 + /// event payload. 1386 1386 + /// 1387 1387 + /// # Safety 1388 1388 + /// `service_name_ptr` must be a valid NUL-terminated UTF-8 string. 1389 1389 + #[no_mangle] 1390 1390 + pub unsafe extern "C" fn rb_subscribe_discovery(service_name_ptr: *const c_char) -> c_int { 1391 1391 + let Some(service_name) = cstr_to_str(service_name_ptr) else { 1392 1392 + return -1; 1393 1393 + }; 1394 1394 + let service_name = service_name.to_string(); 1395 1395 + spawn_stream(move |tx| async move { 1396 1396 + let stream = rockbox_discovery::discover(&service_name); 1397 1397 + pin_mut!(stream); 1398 1398 + while let Some(info) = stream.next().await { 1399 1399 + let payload = DiscoveryEventJson { 1400 1400 + name: info.get_hostname().to_string(), 1401 1401 + fullname: info.get_fullname().to_string(), 1402 1402 + hostname: info.get_hostname().to_string(), 1403 1403 + port: info.get_port(), 1404 1404 + addresses: info.get_addresses().iter().map(|a| a.to_string()).collect(), 1405 1405 + properties: info 1406 1406 + .get_properties() 1407 1407 + .iter() 1408 1408 + .map(|(k, v)| (k.clone(), v.clone())) 1409 1409 + .collect(), 1410 1410 + }; 1411 1411 + let json = serde_json::to_string(&payload).unwrap_or_else(|_| "{}".into()); 1412 1412 + if tx.send(json).await.is_err() { 1413 1413 + break; 1414 1414 + } 1415 1415 + } 1416 1416 + }) 1417 1417 + } 1418 1418 + 1419 1419 + /// Returns the well-known mDNS service name for the rockboxd gRPC daemon 1420 1420 + /// (`_rockbox._tcp.local.`) as a heap C string. Free with `rb_free_string`. 1421 1421 + #[no_mangle] 1422 1422 + pub extern "C" fn rb_rockbox_service_name() -> *mut c_char { 1423 1423 + CString::new(rockbox_discovery::ROCKBOX_SERVICE_NAME) 1424 1424 + .map(|c| c.into_raw()) 1425 1425 + .unwrap_or(std::ptr::null_mut()) 1426 1426 + } 1427 1427 + 1428 1428 + /// Returns the well-known mDNS service name for Chromecast devices. 1429 1429 + #[no_mangle] 1430 1430 + pub extern "C" fn rb_chromecast_service_name() -> *mut c_char { 1431 1431 + CString::new(rockbox_discovery::CHROMECAST_SERVICE_NAME) 1432 1432 + .map(|c| c.into_raw()) 1433 1433 + .unwrap_or(std::ptr::null_mut()) 1434 1434 + } 1435 1435 + 1436 1436 + /// Subscribes to `LibraryService::StreamLibrary`. Each event is the full 1437 1437 + /// (potentially large) library snapshot serialized as JSON. 1438 1438 + #[no_mangle] 1439 1439 + pub extern "C" fn rb_subscribe_library() -> c_int { 1440 1440 + let server_url = url(); 1441 1441 + spawn_stream(move |tx| async move { 1442 1442 + match LibraryServiceClient::connect(server_url).await { 1443 1443 + Ok(mut c) => match c.stream_library(StreamLibraryRequest {}).await { 1444 1444 + Ok(resp) => { 1445 1445 + let mut s = resp.into_inner(); 1446 1446 + while let Ok(Some(msg)) = s.message().await { 1447 1447 + let payload = serde_json::to_string(&msg).unwrap_or_else(|_| "{}".into()); 1448 1448 + if tx.send(payload).await.is_err() { 1449 1449 + break; 1450 1450 + } 1451 1451 + } 1452 1452 + } 1453 1453 + Err(e) => { 1454 1454 + let _ = tx 1455 1455 + .send( 1456 1456 + serde_json::to_string(&StreamErrorJson { 1457 1457 + error: format!("stream_library: {e}"), 1458 1458 + }) 1459 1459 + .unwrap_or_default(), 1460 1460 + ) 1461 1461 + .await; 1462 1462 + } 1463 1463 + }, 1464 1464 + Err(e) => { 1465 1465 + let _ = tx 1466 1466 + .send( 1467 1467 + serde_json::to_string(&StreamErrorJson { 1468 1468 + error: format!("connect: {e}"), 1469 1469 + }) 1470 1470 + .unwrap_or_default(), 1471 1471 + ) 1472 1472 + .await; 1473 1473 + } 1474 1474 + } 1475 1475 + }) 1476 1476 + } 1477 1477 + 1478 1478 + /// Blocks up to `timeout_ms` waiting for the next event on subscription 1479 1479 + /// `sub_id`. Returns a heap-owned JSON C string (free with `rb_free_string`), 1480 1480 + /// or null on timeout / closed stream / unknown subscription. 1481 1481 + #[no_mangle] 1482 1482 + pub extern "C" fn rb_poll_event(sub_id: c_int, timeout_ms: c_int) -> *mut c_char { 1483 1483 + // Take the receiver out of the map briefly so we don't hold the lock 1484 1484 + // across the blocking await. Put it back unless it's been closed. 1485 1485 + let mut rx = { 1486 1486 + let mut map = match SUBS.write() { 1487 1487 + Ok(m) => m, 1488 1488 + Err(_) => return std::ptr::null_mut(), 1489 1489 + }; 1490 1490 + match map.remove(&sub_id) { 1491 1491 + Some(s) => s, 1492 1492 + None => return std::ptr::null_mut(), 1493 1493 + } 1494 1494 + }; 1495 1495 + 1496 1496 + let timeout = if timeout_ms < 0 { 1497 1497 + Duration::from_secs(60 * 60) 1498 1498 + } else { 1499 1499 + Duration::from_millis(timeout_ms as u64) 1500 1500 + }; 1501 1501 + 1502 1502 + let received = RT.block_on(async { tokio::time::timeout(timeout, rx.rx.recv()).await }); 1503 1503 + 1504 1504 + let payload = match received { 1505 1505 + Ok(Some(msg)) => Some(msg), 1506 1506 + Ok(None) => None, // sender dropped → stream closed 1507 1507 + Err(_) => Some(String::new()), // marker: timeout, sub still alive 1508 1508 + }; 1509 1509 + 1510 1510 + // Re-insert if the stream is still alive (any non-None payload). 1511 1511 + if payload.is_some() { 1512 1512 + if let Ok(mut map) = SUBS.write() { 1513 1513 + map.insert(sub_id, rx); 1514 1514 + } 1515 1515 + } else { 1516 1516 + // Stream closed — make sure the task is gone too. 1517 1517 + rx.abort.abort(); 1518 1518 + } 1519 1519 + 1520 1520 + match payload { 1521 1521 + Some(s) if s.is_empty() => std::ptr::null_mut(), 1522 1522 + Some(s) => CString::new(s) 1523 1523 + .map(|c| c.into_raw()) 1524 1524 + .unwrap_or(std::ptr::null_mut()), 1525 1525 + None => std::ptr::null_mut(), 1526 1526 + } 1527 1527 + } 1528 1528 + 1529 1529 + /// Cancels and removes a subscription. Returns 0 if found, -1 otherwise. 1530 1530 + #[no_mangle] 1531 1531 + pub extern "C" fn rb_unsubscribe(sub_id: c_int) -> c_int { 1532 1532 + let removed = match SUBS.write() { 1533 1533 + Ok(mut m) => m.remove(&sub_id), 1534 1534 + Err(_) => return -1, 1535 1535 + }; 1536 1536 + match removed { 1537 1537 + Some(s) => { 1538 1538 + s.abort.abort(); 1539 1539 + 0 1540 1540 + } 1541 1541 + None => -1, 1542 1542 + } 1543 1543 + } 1544 1544 + 1545 1545 + // Reference values so the linker keeps the connect timeout default usable 1546 1546 + // after stripping. (Defensive — some link configurations drop unused symbols.) 1547 1547 + #[doc(hidden)] 1548 1548 + pub fn _link_keepalive() -> Duration { 1549 1549 + Duration::from_secs(5) 1550 1550 + }

+3

expo/bun.lock

reviewed

··· 33 33 "react-native-screens": "~4.16.0", 34 34 "react-native-web": "~0.21.0", 35 35 "react-native-worklets": "0.5.1", 36 36 + "rockbox-rpc": "file:./modules/rockbox-rpc", 36 37 }, 37 38 "devDependencies": { 38 39 "@types/react": "~19.1.0", ··· 1485 1486 "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="], 1486 1487 1487 1488 "rimraf": ["rimraf@3.0.2", "", { "dependencies": { "glob": "^7.1.3" }, "bin": { "rimraf": "bin.js" } }, "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA=="], 1489 1489 + 1490 1490 + "rockbox-rpc": ["rockbox-rpc@file:modules/rockbox-rpc", { "peerDependencies": { "expo": "*", "react": "*", "react-native": "*" } }], 1488 1491 1489 1492 "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="], 1490 1493

+356

expo/lib/rockbox-client.ts

reviewed

··· 1 1 + /** 2 2 + * Thin wrapper around the `rockbox-rpc` native module. 3 3 + * 4 4 + * - On iOS / Android, delegates to the native module (which calls into the 5 5 + * `rockbox-expo` Rust crate via JNI / Swift's `@_silgen_name`). 6 6 + * - On web / when the native module isn't built yet, throws a friendly error 7 7 + * from `requireNativeModule`. Callers should guard with `isAvailable` and 8 8 + * fall back to the mock `PlayerProvider` ticker. 9 9 + */ 10 10 + import { Platform } from "react-native"; 11 11 + import type { 12 12 + DiscoveredService, 13 13 + PlaylistSnapshot, 14 14 + StatusSnapshot, 15 15 + StreamErrorEvent, 16 16 + TrackSnapshot, 17 17 + } from "rockbox-rpc"; 18 18 + 19 19 + let nativeModule: 20 20 + | typeof import("rockbox-rpc").default 21 21 + | null = null; 22 22 + 23 23 + if (Platform.OS === "ios" || Platform.OS === "android") { 24 24 + try { 25 25 + // eslint-disable-next-line @typescript-eslint/no-require-imports 26 26 + nativeModule = require("rockbox-rpc").default; 27 27 + } catch { 28 28 + nativeModule = null; 29 29 + } 30 30 + } 31 31 + 32 32 + export const isAvailable = nativeModule !== null; 33 33 + 34 34 + function require_(): NonNullable<typeof nativeModule> { 35 35 + if (!nativeModule) { 36 36 + throw new Error( 37 37 + "rockbox-rpc native module not available — run `bun run build:ios` or `build:android` from `expo/modules/rockbox-rpc/`", 38 38 + ); 39 39 + } 40 40 + return nativeModule; 41 41 + } 42 42 + 43 43 + export const RockboxClient = { 44 44 + isAvailable, 45 45 + 46 46 + setServerUrl(url: string) { 47 47 + require_().setServerUrl(url); 48 48 + }, 49 49 + 50 50 + ping(): Promise<boolean> { 51 51 + return require_().ping(); 52 52 + }, 53 53 + 54 54 + // Playback 55 55 + play() { 56 56 + return require_().play(); 57 57 + }, 58 58 + pause() { 59 59 + return require_().pause(); 60 60 + }, 61 61 + playPause() { 62 62 + return require_().playPause(); 63 63 + }, 64 64 + next() { 65 65 + return require_().next(); 66 66 + }, 67 67 + prev() { 68 68 + return require_().prev(); 69 69 + }, 70 70 + seek(positionMs: number) { 71 71 + return require_().seek(positionMs); 72 72 + }, 73 73 + 74 74 + // Read 75 75 + status(): Promise<StatusSnapshot> { 76 76 + return require_().status(); 77 77 + }, 78 78 + currentTrack(): Promise<TrackSnapshot> { 79 79 + return require_().currentTrack(); 80 80 + }, 81 81 + 82 82 + // Playback (extended) 83 83 + resumeTrack() { 84 84 + return require_().resumeTrack(); 85 85 + }, 86 86 + playlistResume() { 87 87 + return require_().playlistResume(); 88 88 + }, 89 89 + playAllTracks() { 90 90 + return require_().playAllTracks(); 91 91 + }, 92 92 + playTrack(path: string) { 93 93 + return require_().playTrack(path); 94 94 + }, 95 95 + playAlbum(albumId: string, shuffle = false) { 96 96 + return require_().playAlbum(albumId, shuffle); 97 97 + }, 98 98 + playArtistTracks(artistId: string, shuffle = false) { 99 99 + return require_().playArtistTracks(artistId, shuffle); 100 100 + }, 101 101 + playDirectory(path: string, shuffle = false, position = -1) { 102 102 + return require_().playDirectory(path, shuffle, position); 103 103 + }, 104 104 + 105 105 + // Queue 106 106 + jumpToQueuePosition(pos: number) { 107 107 + return require_().jumpToQueuePosition(pos); 108 108 + }, 109 109 + shufflePlaylistAtStart() { 110 110 + return require_().shufflePlaylist(); 111 111 + }, 112 112 + insertTracks(paths: string[], position: number, shuffle = false) { 113 113 + return require_().insertTracks(paths, position, shuffle); 114 114 + }, 115 115 + insertTrackNext(path: string) { 116 116 + return require_().insertTrackNext(path); 117 117 + }, 118 118 + insertTrackLast(path: string) { 119 119 + return require_().insertTrackLast(path); 120 120 + }, 121 121 + insertDirectory(path: string, position: number) { 122 122 + return require_().insertDirectory(path, position); 123 123 + }, 124 124 + removeFromQueue(pos: number) { 125 125 + return require_().removeFromQueue(pos); 126 126 + }, 127 127 + getPlaylistCurrent() { 128 128 + return require_().getPlaylistCurrent(); 129 129 + }, 130 130 + 131 131 + // Library 132 132 + likeTrack(id: string) { 133 133 + return require_().likeTrack(id); 134 134 + }, 135 135 + unlikeTrack(id: string) { 136 136 + return require_().unlikeTrack(id); 137 137 + }, 138 138 + getTracks() { 139 139 + return require_().getTracks(); 140 140 + }, 141 141 + getArtists() { 142 142 + return require_().getArtists(); 143 143 + }, 144 144 + getAlbum(id: string) { 145 145 + return require_().getAlbum(id); 146 146 + }, 147 147 + getLikedTracks() { 148 148 + return require_().getLikedTracks(); 149 149 + }, 150 150 + search(term: string) { 151 151 + return require_().search(term); 152 152 + }, 153 153 + 154 154 + // Sound 155 155 + adjustVolume(steps: number) { 156 156 + return require_().adjustVolume(steps); 157 157 + }, 158 158 + soundCurrent(setting: number) { 159 159 + return require_().soundCurrent(setting); 160 160 + }, 161 161 + 162 162 + // Settings 163 163 + saveShuffle(enabled: boolean) { 164 164 + return require_().saveShuffle(enabled); 165 165 + }, 166 166 + saveRepeat(mode: number) { 167 167 + return require_().saveRepeat(mode); 168 168 + }, 169 169 + getGlobalSettings() { 170 170 + return require_().getGlobalSettings(); 171 171 + }, 172 172 + getGlobalStatus() { 173 173 + return require_().getGlobalStatus(); 174 174 + }, 175 175 + 176 176 + // Browse 177 177 + treeGetEntries(path: string | null = null) { 178 178 + return require_().treeGetEntries(path); 179 179 + }, 180 180 + 181 181 + // Saved playlists 182 182 + getSavedPlaylists() { 183 183 + return require_().getSavedPlaylists(); 184 184 + }, 185 185 + createSavedPlaylist( 186 186 + name: string, 187 187 + description: string | null = null, 188 188 + trackIds: string[] = [], 189 189 + ) { 190 190 + return require_().createSavedPlaylist(name, description, trackIds); 191 191 + }, 192 192 + updateSavedPlaylist(id: string, name: string, description: string | null = null) { 193 193 + return require_().updateSavedPlaylist(id, name, description); 194 194 + }, 195 195 + deleteSavedPlaylist(id: string) { 196 196 + return require_().deleteSavedPlaylist(id); 197 197 + }, 198 198 + addTrackToPlaylist(playlistId: string, trackId: string) { 199 199 + return require_().addTrackToPlaylist(playlistId, trackId); 200 200 + }, 201 201 + removeTrackFromPlaylist(playlistId: string, trackId: string) { 202 202 + return require_().removeTrackFromPlaylist(playlistId, trackId); 203 203 + }, 204 204 + getSavedPlaylistTracks(playlistId: string) { 205 205 + return require_().getSavedPlaylistTracks(playlistId); 206 206 + }, 207 207 + playSavedPlaylist(playlistId: string) { 208 208 + return require_().playSavedPlaylist(playlistId); 209 209 + }, 210 210 + 211 211 + // Smart playlists 212 212 + getSmartPlaylists() { 213 213 + return require_().getSmartPlaylists(); 214 214 + }, 215 215 + getSmartPlaylistTracks(id: string) { 216 216 + return require_().getSmartPlaylistTracks(id); 217 217 + }, 218 218 + playSmartPlaylist(id: string) { 219 219 + return require_().playSmartPlaylist(id); 220 220 + }, 221 221 + 222 222 + // Bluetooth 223 223 + bluetoothAvailable() { 224 224 + return require_().bluetoothAvailable(); 225 225 + }, 226 226 + getBluetoothDevices() { 227 227 + return require_().getBluetoothDevices(); 228 228 + }, 229 229 + connectBluetooth(address: string) { 230 230 + return require_().connectBluetooth(address); 231 231 + }, 232 232 + disconnectBluetooth(address: string) { 233 233 + return require_().disconnectBluetooth(address); 234 234 + }, 235 235 + 236 236 + // mDNS service-name constants 237 237 + rockboxServiceName() { 238 238 + return require_().rockboxServiceName(); 239 239 + }, 240 240 + chromecastServiceName() { 241 241 + return require_().chromecastServiceName(); 242 242 + }, 243 243 + 244 244 + // ── Streaming subscriptions ───────────────────────────────────────────── 245 245 + // Each helper returns an unsubscribe function that tears down both the 246 246 + // event listener and the native subscription. 247 247 + 248 248 + subscribeStatus( 249 249 + onEvent: (s: StatusSnapshot) => void, 250 250 + onError?: (e: StreamErrorEvent) => void, 251 251 + ): () => void { 252 252 + const m = require_(); 253 253 + const subId = m.subscribeStatus(); 254 254 + const evtSub = m.addListener("rockbox.status", onEvent); 255 255 + const errSub = onError 256 256 + ? m.addListener("rockbox.error", (e) => { 257 257 + if (e.subId === subId) onError(e); 258 258 + }) 259 259 + : null; 260 260 + return () => { 261 261 + evtSub.remove(); 262 262 + errSub?.remove(); 263 263 + m.unsubscribe(subId); 264 264 + }; 265 265 + }, 266 266 + 267 267 + subscribeCurrentTrack( 268 268 + onEvent: (t: TrackSnapshot) => void, 269 269 + onError?: (e: StreamErrorEvent) => void, 270 270 + ): () => void { 271 271 + const m = require_(); 272 272 + const subId = m.subscribeCurrentTrack(); 273 273 + const evtSub = m.addListener("rockbox.currentTrack", onEvent); 274 274 + const errSub = onError 275 275 + ? m.addListener("rockbox.error", (e) => { 276 276 + if (e.subId === subId) onError(e); 277 277 + }) 278 278 + : null; 279 279 + return () => { 280 280 + evtSub.remove(); 281 281 + errSub?.remove(); 282 282 + m.unsubscribe(subId); 283 283 + }; 284 284 + }, 285 285 + 286 286 + subscribePlaylist( 287 287 + onEvent: (p: PlaylistSnapshot) => void, 288 288 + onError?: (e: StreamErrorEvent) => void, 289 289 + ): () => void { 290 290 + const m = require_(); 291 291 + const subId = m.subscribePlaylist(); 292 292 + const evtSub = m.addListener("rockbox.playlist", onEvent); 293 293 + const errSub = onError 294 294 + ? m.addListener("rockbox.error", (e) => { 295 295 + if (e.subId === subId) onError(e); 296 296 + }) 297 297 + : null; 298 298 + return () => { 299 299 + evtSub.remove(); 300 300 + errSub?.remove(); 301 301 + m.unsubscribe(subId); 302 302 + }; 303 303 + }, 304 304 + 305 305 + subscribeLibrary( 306 306 + onEvent: (snapshot: unknown) => void, 307 307 + onError?: (e: StreamErrorEvent) => void, 308 308 + ): () => void { 309 309 + const m = require_(); 310 310 + const subId = m.subscribeLibrary(); 311 311 + const evtSub = m.addListener("rockbox.library", onEvent); 312 312 + const errSub = onError 313 313 + ? m.addListener("rockbox.error", (e) => { 314 314 + if (e.subId === subId) onError(e); 315 315 + }) 316 316 + : null; 317 317 + return () => { 318 318 + evtSub.remove(); 319 319 + errSub?.remove(); 320 320 + m.unsubscribe(subId); 321 321 + }; 322 322 + }, 323 323 + 324 324 + /** 325 325 + * Discover rockbox / Chromecast / arbitrary mDNS services on the LAN. 326 326 + * Defaults to `_rockbox._tcp.local.` when `serviceName` is omitted. 327 327 + */ 328 328 + subscribeDiscovery( 329 329 + onEvent: (service: DiscoveredService) => void, 330 330 + onError?: (e: StreamErrorEvent) => void, 331 331 + serviceName?: string, 332 332 + ): () => void { 333 333 + const m = require_(); 334 334 + const name = serviceName ?? m.rockboxServiceName(); 335 335 + const subId = m.subscribeDiscovery(name); 336 336 + const evtSub = m.addListener("rockbox.discovery", onEvent); 337 337 + const errSub = onError 338 338 + ? m.addListener("rockbox.error", (e) => { 339 339 + if (e.subId === subId) onError(e); 340 340 + }) 341 341 + : null; 342 342 + return () => { 343 343 + evtSub.remove(); 344 344 + errSub?.remove(); 345 345 + m.unsubscribe(subId); 346 346 + }; 347 347 + }, 348 348 + }; 349 349 + 350 350 + export type { 351 351 + DiscoveredService, 352 352 + PlaylistSnapshot, 353 353 + StatusSnapshot, 354 354 + StreamErrorEvent, 355 355 + TrackSnapshot, 356 356 + };

+221

expo/modules/rockbox-rpc/README.md

reviewed

··· 1 1 + # `rockbox-rpc` — Expo native module 2 2 + 3 3 + Expo Modules wrapper around the [`rockbox-expo`](../../../crates/expo/) Rust 4 4 + crate. Exposes the rockboxd gRPC client and the mDNS discovery surface to 5 5 + the React Native app under one TypeScript API. 6 6 + 7 7 + ```ts 8 8 + import RockboxRpc from "rockbox-rpc"; 9 9 + // or via the helper that adds an `isAvailable` guard: 10 10 + import { RockboxClient } from "@/lib/rockbox-client"; 11 11 + ``` 12 12 + 13 13 + This module is autolinked into [`expo/`](../..) via 14 14 + `"rockbox-rpc": "file:./modules/rockbox-rpc"` in `expo/package.json`. A 15 15 + `postinstall` hook (`expo/scripts/link-rockbox-rpc.js`) replaces the 16 16 + copied directory in `node_modules/` with a live symlink so edits to the 17 17 + TypeScript / Swift / Kotlin source show up immediately. 18 18 + 19 19 + ## Layout 20 20 + 21 21 + ``` 22 22 + modules/rockbox-rpc/ 23 23 + ├── expo-module.config.json declares iOS + Android module classes 24 24 + ├── package.json local "file:" dependency 25 25 + ├── src/index.ts TypeScript surface (types + native interface) 26 26 + ├── ios/ 27 27 + │ ├── RockboxRpc.podspec vendored xcframework + ExpoModulesCore dep 28 28 + │ └── RockboxRpcModule.swift @_silgen_name extern declarations + bindings 29 29 + ├── android/ 30 30 + │ ├── build.gradle jniLibs.srcDirs wired to src/main/jniLibs 31 31 + │ └── src/main/java/expo/modules/rockboxrpc/RockboxRpcModule.kt 32 32 + └── scripts/ 33 33 + ├── build-ios.sh cross-compile + lipo + xcframework bundle 34 34 + └── build-android.sh cargo-ndk → jniLibs/<abi>/librockbox_expo.so 35 35 + ``` 36 36 + 37 37 + ## Building the native libs 38 38 + 39 39 + You only need to run these once per code change in `crates/expo/`: 40 40 + 41 41 + ```sh 42 42 + # iOS — produces ios/RockboxExpo.xcframework 43 43 + rustup target add aarch64-apple-ios aarch64-apple-ios-sim x86_64-apple-ios 44 44 + bun run build:ios 45 45 + 46 46 + # Android — produces android/src/main/jniLibs/<abi>/librockbox_expo.so 47 47 + cargo install cargo-ndk 48 48 + rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android 49 49 + export ANDROID_NDK_HOME=... # NDK r25+ 50 50 + bun run build:android 51 51 + ``` 52 52 + 53 53 + After the artifacts are in place, run `bunx expo prebuild` and then 54 54 + `bunx expo run:ios` / `run:android` from the `expo/` root. 55 55 + 56 56 + ## API surface 57 57 + 58 58 + ### Init / health 59 59 + 60 60 + ```ts 61 61 + RockboxClient.setServerUrl("http://192.168.1.10:6061"); // call once at startup 62 62 + await RockboxClient.ping(); // → true on success 63 63 + ``` 64 64 + 65 65 + `isAvailable` is `false` on web / before the native libs are built; the JS 66 66 + helper falls back to throwing a friendly error so the rest of the app can 67 67 + keep using the mock `PlayerProvider`. 68 68 + 69 69 + ### Playback 70 70 + 71 71 + ```ts 72 72 + await RockboxClient.play(); 73 73 + await RockboxClient.pause(); 74 74 + await RockboxClient.playPause(); 75 75 + await RockboxClient.next(); 76 76 + await RockboxClient.prev(); 77 77 + await RockboxClient.seek(positionMs); 78 78 + 79 79 + await RockboxClient.playTrack("/Music/foo.flac"); 80 80 + await RockboxClient.playAlbum(albumId, /* shuffle */ true); 81 81 + await RockboxClient.playArtistTracks(artistId, false); 82 82 + await RockboxClient.playAllTracks(); 83 83 + await RockboxClient.playDirectory(path, false, /* position = -1 means "no override" */ -1); 84 84 + ``` 85 85 + 86 86 + ### Queue 87 87 + 88 88 + ```ts 89 89 + await RockboxClient.jumpToQueuePosition(idx); 90 90 + await RockboxClient.insertTracks(paths, /* position */ -3, /* shuffle */ false); 91 91 + await RockboxClient.insertTrackNext(path); 92 92 + await RockboxClient.insertTrackLast(path); 93 93 + await RockboxClient.insertDirectory(path, position); 94 94 + await RockboxClient.removeFromQueue(pos); 95 95 + await RockboxClient.shufflePlaylistAtStart(); 96 96 + 97 97 + const snapshot = await RockboxClient.getPlaylistCurrent(); 98 98 + ``` 99 99 + 100 100 + ### Library / search 101 101 + 102 102 + ```ts 103 103 + const tracks = await RockboxClient.getTracks(); 104 104 + const artists = await RockboxClient.getArtists(); 105 105 + const album = await RockboxClient.getAlbum(id); 106 106 + const liked = await RockboxClient.getLikedTracks(); 107 107 + const results = await RockboxClient.search("aphex twin"); 108 108 + 109 109 + await RockboxClient.likeTrack(trackId); 110 110 + await RockboxClient.unlikeTrack(trackId); 111 111 + ``` 112 112 + 113 113 + ### Sound / settings 114 114 + 115 115 + ```ts 116 116 + await RockboxClient.adjustVolume(+2); 117 117 + const v = await RockboxClient.soundCurrent(/* SOUND_VOLUME = 0 */ 0); 118 118 + 119 119 + await RockboxClient.saveShuffle(true); 120 120 + await RockboxClient.saveRepeat(/* off=0 all=1 one=2 */ 1); 121 121 + 122 122 + const status = await RockboxClient.getGlobalStatus(); 123 123 + const settings = await RockboxClient.getGlobalSettings(); 124 124 + ``` 125 125 + 126 126 + ### Saved / smart playlists 127 127 + 128 128 + ```ts 129 129 + const playlists = await RockboxClient.getSavedPlaylists(); 130 130 + await RockboxClient.createSavedPlaylist("Faves", "best of 2024", [trackId1, trackId2]); 131 131 + await RockboxClient.updateSavedPlaylist(id, "New name", null); 132 132 + await RockboxClient.deleteSavedPlaylist(id); 133 133 + await RockboxClient.addTrackToPlaylist(playlistId, trackId); 134 134 + await RockboxClient.removeTrackFromPlaylist(playlistId, trackId); 135 135 + const trackIds = await RockboxClient.getSavedPlaylistTracks(playlistId); 136 136 + await RockboxClient.playSavedPlaylist(playlistId); 137 137 + 138 138 + const smart = await RockboxClient.getSmartPlaylists(); 139 139 + await RockboxClient.playSmartPlaylist(id); 140 140 + ``` 141 141 + 142 142 + ### Browse + Bluetooth 143 143 + 144 144 + ```ts 145 145 + const root = await RockboxClient.treeGetEntries(null); 146 146 + const sub = await RockboxClient.treeGetEntries("/Music/Albums"); 147 147 + 148 148 + if (await RockboxClient.bluetoothAvailable()) { 149 149 + const devices = await RockboxClient.getBluetoothDevices(); 150 150 + await RockboxClient.connectBluetooth(address); 151 151 + await RockboxClient.disconnectBluetooth(address); 152 152 + } 153 153 + ``` 154 154 + 155 155 + ### Streaming subscriptions 156 156 + 157 157 + Each helper returns a single `() => void` that tears down both the event 158 158 + listener and the native subscription: 159 159 + 160 160 + ```ts 161 161 + const unsubStatus = RockboxClient.subscribeStatus( 162 162 + (s) => setStatus(s.status), 163 163 + (e) => console.warn("status stream error", e.error), 164 164 + ); 165 165 + 166 166 + const unsubTrack = RockboxClient.subscribeCurrentTrack((t) => setTrack(t)); 167 167 + const unsubQueue = RockboxClient.subscribePlaylist((p) => setQueue(p.tracks)); 168 168 + const unsubLib = RockboxClient.subscribeLibrary((snapshot) => /* refresh */ null); 169 169 + 170 170 + // LAN scan — defaults to "_rockbox._tcp.local."; pass any other Bonjour name 171 171 + // for Chromecast etc. 172 172 + const unsubScan = RockboxClient.subscribeDiscovery( 173 173 + (svc) => console.log("found", svc.name, svc.addresses, svc.port), 174 174 + undefined, 175 175 + RockboxClient.chromecastServiceName(), 176 176 + ); 177 177 + 178 178 + // later: 179 179 + unsubStatus(); unsubTrack(); unsubQueue(); unsubLib(); unsubScan(); 180 180 + ``` 181 181 + 182 182 + Topics surfaced through the EventEmitter base class: 183 183 + 184 184 + | Topic | Payload | 185 185 + |-------|---------| 186 186 + | `rockbox.status` | `{ status: 0|1|2 }` | 187 187 + | `rockbox.currentTrack` | `TrackSnapshot` | 188 188 + | `rockbox.playlist` | `PlaylistSnapshot` (`index`, `amount`, `tracks`) | 189 189 + | `rockbox.library` | full library snapshot (`unknown` — cast as needed) | 190 190 + | `rockbox.discovery` | `DiscoveredService` (`name`, `hostname`, `port`, `addresses[]`, `properties{}`) | 191 191 + | `rockbox.error` | `{ subId, stream, error }` | 192 192 + 193 193 + ## Adding a new method 194 194 + 195 195 + 1. Add the `rb_<name>` wrapper in [`crates/expo/src/lib.rs`](../../../crates/expo/src/lib.rs). 196 196 + 2. Declare the symbol on both platforms: 197 197 + - Swift (`ios/RockboxRpcModule.swift`): `@_silgen_name(...) private func ...` 198 198 + - Kotlin (`android/src/main/java/.../RockboxRpcModule.kt`): `@JvmStatic external fun ...` 199 199 + 3. Add a `Function` / `AsyncFunction` binding in each platform module. 200 200 + 4. Add the typed method to `src/index.ts` (`RockboxRpcNative`) and a 201 201 + one-line forwarder on `RockboxClient` in `expo/lib/rockbox-client.ts`. 202 202 + 5. Rebuild the native libs (`bun run build:ios` / `build:android`). 203 203 + 204 204 + ## Troubleshooting 205 205 + 206 206 + - **`requireNativeModule("RockboxRpc")` fails** — the native libs aren't 207 207 + built. Run `bun run build:ios` / `build:android` (and re-prebuild the 208 208 + iOS / Android projects). 209 209 + - **`UnsatisfiedLinkError: librockbox_expo.so`** — the `.so` for the 210 210 + current ABI is missing from `android/src/main/jniLibs/`. Make sure 211 211 + `cargo-ndk` ran successfully for that ABI. 212 212 + - **iOS simulator can't find symbols** — the xcframework needs both the 213 213 + device and simulator slices. Check that `lipo -info` reports both 214 214 + `arm64` and `x86_64` for the simulator library before xcframework packing. 215 215 + - **Linker error referencing `_dispatch_main_q`** — link `c++` and `resolv` 216 216 + (already declared in the podspec). 217 217 + - **TypeScript can't find `rockbox-rpc`** — bun copied the dir instead of 218 218 + symlinking it; the `postinstall` hook replaces it. Re-run `bun install`. 219 219 + 220 220 + See [`crates/expo/README.md`](../../../crates/expo/README.md) for the 221 221 + full list of FFI symbols and the Rust-side conventions.

+1

expo/modules/rockbox-rpc/android/.gitignore

reviewed

··· 1 1 + build/

+27

expo/modules/rockbox-rpc/android/build.gradle

reviewed

··· 1 1 + plugins { 2 2 + id 'com.android.library' 3 3 + id 'expo-module-gradle-plugin' 4 4 + } 5 5 + 6 6 + group = 'expo.modules.rockboxrpc' 7 7 + version = '0.1.0' 8 8 + 9 9 + android { 10 10 + namespace 'expo.modules.rockboxrpc' 11 11 + defaultConfig { 12 12 + minSdkVersion 24 13 13 + versionCode 1 14 14 + versionName '0.1.0' 15 15 + } 16 16 + // The .so artifacts produced by scripts/build-android.sh are dropped into 17 17 + // src/main/jniLibs/<abi>/ — link them directly into the AAR. 18 18 + sourceSets { 19 19 + main { 20 20 + jniLibs.srcDirs = ['src/main/jniLibs'] 21 21 + } 22 22 + } 23 23 + } 24 24 + 25 25 + dependencies { 26 26 + implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4' 27 27 + }

+4

expo/modules/rockbox-rpc/android/src/main/AndroidManifest.xml

reviewed

··· 1 1 + <?xml version="1.0" encoding="utf-8"?> 2 2 + <manifest xmlns:android="http://schemas.android.com/apk/res/android"> 3 3 + <uses-permission android:name="android.permission.INTERNET" /> 4 4 + </manifest>

+414

expo/modules/rockbox-rpc/android/src/main/java/expo/modules/rockboxrpc/RockboxRpcModule.kt

reviewed

··· 1 1 + package expo.modules.rockboxrpc 2 2 + 3 3 + import expo.modules.kotlin.modules.Module 4 4 + import expo.modules.kotlin.modules.ModuleDefinition 5 5 + import kotlinx.coroutines.CoroutineScope 6 6 + import kotlinx.coroutines.Dispatchers 7 7 + import kotlinx.coroutines.Job 8 8 + import kotlinx.coroutines.cancel 9 9 + import kotlinx.coroutines.isActive 10 10 + import kotlinx.coroutines.launch 11 11 + import org.json.JSONObject 12 12 + import java.util.concurrent.ConcurrentHashMap 13 13 + 14 14 + /** 15 15 + * Native module wrapping the rockbox-expo Rust crate (built into a .so per ABI 16 16 + * and dropped into android/src/main/jniLibs/). 17 17 + * 18 18 + * The C ABI is a 1:1 mapping of `rb_*` functions in `crates/expo/src/lib.rs`. 19 19 + * String returns are heap-owned in Rust and freed by `rb_free_string` on the 20 20 + * Kotlin side after copying. 21 21 + */ 22 22 + class RockboxRpcModule : Module() { 23 23 + companion object { 24 24 + init { 25 25 + System.loadLibrary("rockbox_expo") 26 26 + } 27 27 + 28 28 + @JvmStatic external fun rb_set_server_url(url: String): Int 29 29 + @JvmStatic external fun rb_ping(): Int 30 30 + @JvmStatic external fun rb_play(): Int 31 31 + @JvmStatic external fun rb_pause(): Int 32 32 + @JvmStatic external fun rb_play_pause(): Int 33 33 + @JvmStatic external fun rb_next(): Int 34 34 + @JvmStatic external fun rb_prev(): Int 35 35 + @JvmStatic external fun rb_seek(positionMs: Int): Int 36 36 + @JvmStatic external fun rb_status_json(): String? 37 37 + @JvmStatic external fun rb_current_track_json(): String? 38 38 + @JvmStatic external fun rb_like_track(id: String): Int 39 39 + @JvmStatic external fun rb_unlike_track(id: String): Int 40 40 + 41 41 + @JvmStatic external fun rb_subscribe_status(): Int 42 42 + @JvmStatic external fun rb_subscribe_current_track(): Int 43 43 + @JvmStatic external fun rb_subscribe_playlist(): Int 44 44 + @JvmStatic external fun rb_subscribe_library(): Int 45 45 + @JvmStatic external fun rb_subscribe_discovery(serviceName: String): Int 46 46 + @JvmStatic external fun rb_rockbox_service_name(): String? 47 47 + @JvmStatic external fun rb_chromecast_service_name(): String? 48 48 + @JvmStatic external fun rb_poll_event(subId: Int, timeoutMs: Int): String? 49 49 + @JvmStatic external fun rb_unsubscribe(subId: Int): Int 50 50 + 51 51 + @JvmStatic external fun rb_resume_track(): Int 52 52 + @JvmStatic external fun rb_playlist_resume(): Int 53 53 + @JvmStatic external fun rb_play_all_tracks(): Int 54 54 + @JvmStatic external fun rb_play_track(path: String): Int 55 55 + @JvmStatic external fun rb_play_album(id: String, shuffle: Int): Int 56 56 + @JvmStatic external fun rb_play_artist_tracks(id: String, shuffle: Int): Int 57 57 + @JvmStatic external fun rb_play_directory(path: String, shuffle: Int, position: Int): Int 58 58 + 59 59 + @JvmStatic external fun rb_jump_to_queue_position(pos: Int): Int 60 60 + @JvmStatic external fun rb_shuffle_playlist(): Int 61 61 + @JvmStatic external fun rb_insert_tracks(pathsJson: String, position: Int, shuffle: Int): Int 62 62 + @JvmStatic external fun rb_insert_track_next(path: String): Int 63 63 + @JvmStatic external fun rb_insert_track_last(path: String): Int 64 64 + @JvmStatic external fun rb_insert_directory(path: String, position: Int): Int 65 65 + @JvmStatic external fun rb_remove_from_queue(pos: Int): Int 66 66 + @JvmStatic external fun rb_get_playlist_current_json(): String? 67 67 + 68 68 + @JvmStatic external fun rb_get_tracks_json(): String? 69 69 + @JvmStatic external fun rb_get_artists_json(): String? 70 70 + @JvmStatic external fun rb_get_album_json(id: String): String? 71 71 + @JvmStatic external fun rb_get_liked_tracks_json(): String? 72 72 + @JvmStatic external fun rb_search_json(term: String): String? 73 73 + 74 74 + @JvmStatic external fun rb_adjust_volume(steps: Int): Int 75 75 + @JvmStatic external fun rb_sound_current_json(setting: Int): String? 76 76 + 77 77 + @JvmStatic external fun rb_save_shuffle(enabled: Int): Int 78 78 + @JvmStatic external fun rb_save_repeat(mode: Int): Int 79 79 + @JvmStatic external fun rb_get_global_settings_json(): String? 80 80 + @JvmStatic external fun rb_get_global_status_json(): String? 81 81 + 82 82 + @JvmStatic external fun rb_tree_get_entries_json(path: String?): String? 83 83 + 84 84 + @JvmStatic external fun rb_get_saved_playlists_json(): String? 85 85 + @JvmStatic external fun rb_create_saved_playlist(name: String, description: String?, idsJson: String?): Int 86 86 + @JvmStatic external fun rb_update_saved_playlist(id: String, name: String, description: String?): Int 87 87 + @JvmStatic external fun rb_delete_saved_playlist(id: String): Int 88 88 + @JvmStatic external fun rb_add_track_to_playlist(playlistId: String, trackId: String): Int 89 89 + @JvmStatic external fun rb_remove_track_from_playlist(playlistId: String, trackId: String): Int 90 90 + @JvmStatic external fun rb_get_saved_playlist_tracks_json(playlistId: String): String? 91 91 + @JvmStatic external fun rb_play_saved_playlist(playlistId: String): Int 92 92 + 93 93 + @JvmStatic external fun rb_get_smart_playlists_json(): String? 94 94 + @JvmStatic external fun rb_get_smart_playlist_tracks_json(id: String): String? 95 95 + @JvmStatic external fun rb_play_smart_playlist(id: String): Int 96 96 + 97 97 + @JvmStatic external fun rb_bluetooth_available(): Int 98 98 + @JvmStatic external fun rb_get_bluetooth_devices_json(): String? 99 99 + @JvmStatic external fun rb_connect_bluetooth(address: String): Int 100 100 + @JvmStatic external fun rb_disconnect_bluetooth(address: String): Int 101 101 + } 102 102 + 103 103 + private val scope = CoroutineScope(Dispatchers.IO) 104 104 + private val pollJobs = ConcurrentHashMap<Int, Job>() 105 105 + 106 106 + override fun definition() = ModuleDefinition { 107 107 + Name("RockboxRpc") 108 108 + 109 109 + Events( 110 110 + "rockbox.status", 111 111 + "rockbox.currentTrack", 112 112 + "rockbox.playlist", 113 113 + "rockbox.library", 114 114 + "rockbox.discovery", 115 115 + "rockbox.error", 116 116 + ) 117 117 + 118 118 + Function("rockboxServiceName") { 119 119 + rb_rockbox_service_name() ?: "_rockbox._tcp.local." 120 120 + } 121 121 + Function("chromecastServiceName") { 122 122 + rb_chromecast_service_name() ?: "_googlecast._tcp.local." 123 123 + } 124 124 + 125 125 + Function("setServerUrl") { url: String -> 126 126 + rb_set_server_url(url) 127 127 + } 128 128 + 129 129 + AsyncFunction("ping") { 130 130 + rb_ping() == 0 131 131 + } 132 132 + 133 133 + AsyncFunction("play") { if (rb_play() != 0) throw RpcError("play") } 134 134 + AsyncFunction("pause") { if (rb_pause() != 0) throw RpcError("pause") } 135 135 + AsyncFunction("playPause") { if (rb_play_pause() != 0) throw RpcError("playPause") } 136 136 + AsyncFunction("next") { if (rb_next() != 0) throw RpcError("next") } 137 137 + AsyncFunction("prev") { if (rb_prev() != 0) throw RpcError("prev") } 138 138 + AsyncFunction("seek") { positionMs: Int -> 139 139 + if (rb_seek(positionMs) != 0) throw RpcError("seek") 140 140 + } 141 141 + 142 142 + AsyncFunction("status") { 143 143 + val json = rb_status_json() ?: throw RpcError("status") 144 144 + jsonToMap(json) 145 145 + } 146 146 + 147 147 + AsyncFunction("currentTrack") { 148 148 + val json = rb_current_track_json() ?: throw RpcError("currentTrack") 149 149 + jsonToMap(json) 150 150 + } 151 151 + 152 152 + AsyncFunction("likeTrack") { id: String -> 153 153 + if (rb_like_track(id) != 0) throw RpcError("likeTrack") 154 154 + } 155 155 + 156 156 + AsyncFunction("unlikeTrack") { id: String -> 157 157 + if (rb_unlike_track(id) != 0) throw RpcError("unlikeTrack") 158 158 + } 159 159 + 160 160 + // ── Comprehensive RPC surface ─────────────────────────────────────────── 161 161 + AsyncFunction("resumeTrack") { if (rb_resume_track() != 0) throw RpcError("resumeTrack") } 162 162 + AsyncFunction("playlistResume") { if (rb_playlist_resume() != 0) throw RpcError("playlistResume") } 163 163 + AsyncFunction("playAllTracks") { if (rb_play_all_tracks() != 0) throw RpcError("playAllTracks") } 164 164 + AsyncFunction("playTrack") { path: String -> 165 165 + if (rb_play_track(path) != 0) throw RpcError("playTrack") 166 166 + } 167 167 + AsyncFunction("playAlbum") { id: String, shuffle: Boolean -> 168 168 + if (rb_play_album(id, if (shuffle) 1 else 0) != 0) throw RpcError("playAlbum") 169 169 + } 170 170 + AsyncFunction("playArtistTracks") { id: String, shuffle: Boolean -> 171 171 + if (rb_play_artist_tracks(id, if (shuffle) 1 else 0) != 0) throw RpcError("playArtistTracks") 172 172 + } 173 173 + AsyncFunction("playDirectory") { path: String, shuffle: Boolean, position: Int -> 174 174 + if (rb_play_directory(path, if (shuffle) 1 else 0, position) != 0) throw RpcError("playDirectory") 175 175 + } 176 176 + 177 177 + AsyncFunction("jumpToQueuePosition") { pos: Int -> 178 178 + if (rb_jump_to_queue_position(pos) != 0) throw RpcError("jumpToQueuePosition") 179 179 + } 180 180 + AsyncFunction("shufflePlaylist") { 181 181 + if (rb_shuffle_playlist() != 0) throw RpcError("shufflePlaylist") 182 182 + } 183 183 + AsyncFunction("insertTracks") { paths: List<String>, position: Int, shuffle: Boolean -> 184 184 + val arr = org.json.JSONArray() 185 185 + for (p in paths) arr.put(p) 186 186 + if (rb_insert_tracks(arr.toString(), position, if (shuffle) 1 else 0) != 0) 187 187 + throw RpcError("insertTracks") 188 188 + } 189 189 + AsyncFunction("insertTrackNext") { path: String -> 190 190 + if (rb_insert_track_next(path) != 0) throw RpcError("insertTrackNext") 191 191 + } 192 192 + AsyncFunction("insertTrackLast") { path: String -> 193 193 + if (rb_insert_track_last(path) != 0) throw RpcError("insertTrackLast") 194 194 + } 195 195 + AsyncFunction("insertDirectory") { path: String, position: Int -> 196 196 + if (rb_insert_directory(path, position) != 0) throw RpcError("insertDirectory") 197 197 + } 198 198 + AsyncFunction("removeFromQueue") { pos: Int -> 199 199 + if (rb_remove_from_queue(pos) != 0) throw RpcError("removeFromQueue") 200 200 + } 201 201 + 202 202 + AsyncFunction("getPlaylistCurrent") { 203 203 + parseJsonOrThrow(rb_get_playlist_current_json(), "getPlaylistCurrent") 204 204 + } 205 205 + AsyncFunction("getTracks") { 206 206 + parseJsonOrThrow(rb_get_tracks_json(), "getTracks") 207 207 + } 208 208 + AsyncFunction("getArtists") { 209 209 + parseJsonOrThrow(rb_get_artists_json(), "getArtists") 210 210 + } 211 211 + AsyncFunction("getAlbum") { id: String -> 212 212 + parseJsonOrThrow(rb_get_album_json(id), "getAlbum") 213 213 + } 214 214 + AsyncFunction("getLikedTracks") { 215 215 + parseJsonOrThrow(rb_get_liked_tracks_json(), "getLikedTracks") 216 216 + } 217 217 + AsyncFunction("search") { term: String -> 218 218 + parseJsonOrThrow(rb_search_json(term), "search") 219 219 + } 220 220 + 221 221 + AsyncFunction("adjustVolume") { steps: Int -> 222 222 + if (rb_adjust_volume(steps) != 0) throw RpcError("adjustVolume") 223 223 + } 224 224 + AsyncFunction("soundCurrent") { setting: Int -> 225 225 + parseJsonOrThrow(rb_sound_current_json(setting), "soundCurrent") 226 226 + } 227 227 + 228 228 + AsyncFunction("saveShuffle") { enabled: Boolean -> 229 229 + if (rb_save_shuffle(if (enabled) 1 else 0) != 0) throw RpcError("saveShuffle") 230 230 + } 231 231 + AsyncFunction("saveRepeat") { mode: Int -> 232 232 + if (rb_save_repeat(mode) != 0) throw RpcError("saveRepeat") 233 233 + } 234 234 + AsyncFunction("getGlobalSettings") { 235 235 + parseJsonOrThrow(rb_get_global_settings_json(), "getGlobalSettings") 236 236 + } 237 237 + AsyncFunction("getGlobalStatus") { 238 238 + parseJsonOrThrow(rb_get_global_status_json(), "getGlobalStatus") 239 239 + } 240 240 + 241 241 + AsyncFunction("treeGetEntries") { path: String? -> 242 242 + parseJsonOrThrow(rb_tree_get_entries_json(path), "treeGetEntries") 243 243 + } 244 244 + 245 245 + AsyncFunction("getSavedPlaylists") { 246 246 + parseJsonOrThrow(rb_get_saved_playlists_json(), "getSavedPlaylists") 247 247 + } 248 248 + AsyncFunction("createSavedPlaylist") { name: String, description: String?, trackIds: List<String> -> 249 249 + val arr = org.json.JSONArray() 250 250 + for (id in trackIds) arr.put(id) 251 251 + if (rb_create_saved_playlist(name, description, arr.toString()) != 0) 252 252 + throw RpcError("createSavedPlaylist") 253 253 + } 254 254 + AsyncFunction("updateSavedPlaylist") { id: String, name: String, description: String? -> 255 255 + if (rb_update_saved_playlist(id, name, description) != 0) throw RpcError("updateSavedPlaylist") 256 256 + } 257 257 + AsyncFunction("deleteSavedPlaylist") { id: String -> 258 258 + if (rb_delete_saved_playlist(id) != 0) throw RpcError("deleteSavedPlaylist") 259 259 + } 260 260 + AsyncFunction("addTrackToPlaylist") { playlistId: String, trackId: String -> 261 261 + if (rb_add_track_to_playlist(playlistId, trackId) != 0) throw RpcError("addTrackToPlaylist") 262 262 + } 263 263 + AsyncFunction("removeTrackFromPlaylist") { playlistId: String, trackId: String -> 264 264 + if (rb_remove_track_from_playlist(playlistId, trackId) != 0) throw RpcError("removeTrackFromPlaylist") 265 265 + } 266 266 + AsyncFunction("getSavedPlaylistTracks") { playlistId: String -> 267 267 + parseJsonOrThrow(rb_get_saved_playlist_tracks_json(playlistId), "getSavedPlaylistTracks") 268 268 + } 269 269 + AsyncFunction("playSavedPlaylist") { playlistId: String -> 270 270 + if (rb_play_saved_playlist(playlistId) != 0) throw RpcError("playSavedPlaylist") 271 271 + } 272 272 + 273 273 + AsyncFunction("getSmartPlaylists") { 274 274 + parseJsonOrThrow(rb_get_smart_playlists_json(), "getSmartPlaylists") 275 275 + } 276 276 + AsyncFunction("getSmartPlaylistTracks") { id: String -> 277 277 + parseJsonOrThrow(rb_get_smart_playlist_tracks_json(id), "getSmartPlaylistTracks") 278 278 + } 279 279 + AsyncFunction("playSmartPlaylist") { id: String -> 280 280 + if (rb_play_smart_playlist(id) != 0) throw RpcError("playSmartPlaylist") 281 281 + } 282 282 + 283 283 + AsyncFunction("bluetoothAvailable") { rb_bluetooth_available() == 1 } 284 284 + AsyncFunction("getBluetoothDevices") { 285 285 + parseJsonOrThrow(rb_get_bluetooth_devices_json(), "getBluetoothDevices") 286 286 + } 287 287 + AsyncFunction("connectBluetooth") { address: String -> 288 288 + if (rb_connect_bluetooth(address) != 0) throw RpcError("connectBluetooth") 289 289 + } 290 290 + AsyncFunction("disconnectBluetooth") { address: String -> 291 291 + if (rb_disconnect_bluetooth(address) != 0) throw RpcError("disconnectBluetooth") 292 292 + } 293 293 + 294 294 + // ── Streaming subscriptions ───────────────────────────────────────────── 295 295 + Function("subscribeStatus") { 296 296 + val id = rb_subscribe_status() 297 297 + startPollLoop(id, "rockbox.status") 298 298 + id 299 299 + } 300 300 + Function("subscribeCurrentTrack") { 301 301 + val id = rb_subscribe_current_track() 302 302 + startPollLoop(id, "rockbox.currentTrack") 303 303 + id 304 304 + } 305 305 + Function("subscribePlaylist") { 306 306 + val id = rb_subscribe_playlist() 307 307 + startPollLoop(id, "rockbox.playlist") 308 308 + id 309 309 + } 310 310 + Function("subscribeLibrary") { 311 311 + val id = rb_subscribe_library() 312 312 + startPollLoop(id, "rockbox.library") 313 313 + id 314 314 + } 315 315 + Function("subscribeDiscovery") { serviceName: String -> 316 316 + val id = rb_subscribe_discovery(serviceName) 317 317 + startPollLoop(id, "rockbox.discovery") 318 318 + id 319 319 + } 320 320 + Function("unsubscribe") { subId: Int -> 321 321 + pollJobs.remove(subId)?.cancel() 322 322 + rb_unsubscribe(subId) 323 323 + } 324 324 + 325 325 + OnDestroy { 326 326 + pollJobs.values.forEach { it.cancel() } 327 327 + pollJobs.clear() 328 328 + scope.cancel() 329 329 + } 330 330 + } 331 331 + 332 332 + private fun startPollLoop(subId: Int, eventName: String) { 333 333 + val job = scope.launch { 334 334 + while (isActive) { 335 335 + val raw = rb_poll_event(subId, 1_000) ?: continue 336 336 + try { 337 337 + val obj = JSONObject(raw) 338 338 + if (obj.has("error")) { 339 339 + sendEvent("rockbox.error", mapOf( 340 340 + "subId" to subId, 341 341 + "error" to obj.getString("error"), 342 342 + "stream" to eventName, 343 343 + )) 344 344 + return@launch 345 345 + } 346 346 + val map = mutableMapOf<String, Any?>() 347 347 + val it = obj.keys() 348 348 + while (it.hasNext()) { 349 349 + val k = it.next() 350 350 + map[k] = if (obj.isNull(k)) null else obj.get(k) 351 351 + } 352 352 + sendEvent(eventName, map) 353 353 + } catch (e: Exception) { 354 354 + // Bad JSON — skip and keep polling. 355 355 + } 356 356 + } 357 357 + } 358 358 + pollJobs[subId] = job 359 359 + } 360 360 + 361 361 + private fun parseJsonOrThrow(s: String?, op: String): Any { 362 362 + if (s == null) throw RpcError(op) 363 363 + val trimmed = s.trim() 364 364 + return when { 365 365 + trimmed.startsWith("{") -> { 366 366 + val obj = JSONObject(trimmed) 367 367 + if (obj.has("error")) throw RpcError("$op: ${obj.getString("error")}") 368 368 + jsonObjectToMap(obj) 369 369 + } 370 370 + trimmed.startsWith("[") -> { 371 371 + val arr = org.json.JSONArray(trimmed) 372 372 + jsonArrayToList(arr) 373 373 + } 374 374 + else -> trimmed 375 375 + } 376 376 + } 377 377 + 378 378 + private fun jsonObjectToMap(obj: JSONObject): Map<String, Any?> { 379 379 + val map = mutableMapOf<String, Any?>() 380 380 + val it = obj.keys() 381 381 + while (it.hasNext()) { 382 382 + val k = it.next() 383 383 + map[k] = unwrap(obj.opt(k)) 384 384 + } 385 385 + return map 386 386 + } 387 387 + 388 388 + private fun jsonArrayToList(arr: org.json.JSONArray): List<Any?> { 389 389 + val out = ArrayList<Any?>(arr.length()) 390 390 + for (i in 0 until arr.length()) out.add(unwrap(arr.opt(i))) 391 391 + return out 392 392 + } 393 393 + 394 394 + private fun unwrap(v: Any?): Any? = when (v) { 395 395 + JSONObject.NULL, null -> null 396 396 + is JSONObject -> jsonObjectToMap(v) 397 397 + is org.json.JSONArray -> jsonArrayToList(v) 398 398 + else -> v 399 399 + } 400 400 + 401 401 + private fun jsonToMap(s: String): Map<String, Any?> { 402 402 + val obj = JSONObject(s) 403 403 + if (obj.has("error")) throw RpcError(obj.getString("error")) 404 404 + val map = mutableMapOf<String, Any?>() 405 405 + val it = obj.keys() 406 406 + while (it.hasNext()) { 407 407 + val k = it.next() 408 408 + map[k] = if (obj.isNull(k)) null else obj.get(k) 409 409 + } 410 410 + return map 411 411 + } 412 412 + } 413 413 + 414 414 + private class RpcError(msg: String) : RuntimeException("rockbox-rpc: $msg")

+9

expo/modules/rockbox-rpc/expo-module.config.json

reviewed

··· 1 1 + { 2 2 + "platforms": ["ios", "android"], 3 3 + "ios": { 4 4 + "modules": ["RockboxRpcModule"] 5 5 + }, 6 6 + "android": { 7 7 + "modules": ["expo.modules.rockboxrpc.RockboxRpcModule"] 8 8 + } 9 9 + }

+31

expo/modules/rockbox-rpc/ios/RockboxRpc.podspec

reviewed

··· 1 1 + require 'json' 2 2 + 3 3 + package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json'))) 4 4 + 5 5 + Pod::Spec.new do |s| 6 6 + s.name = 'RockboxRpc' 7 7 + s.version = package['version'] 8 8 + s.summary = package['description'] 9 9 + s.description = package['description'] 10 10 + s.license = 'LGPL-2.1' 11 11 + s.author = 'Rockbox Zig' 12 12 + s.homepage = 'https://github.com/tsirysndr/rockbox-zig' 13 13 + s.platforms = { :ios => '15.1', :tvos => '15.1' } 14 14 + s.swift_version = '5.9' 15 15 + s.source = { git: '' } 16 16 + s.static_framework = true 17 17 + 18 18 + s.dependency 'ExpoModulesCore' 19 19 + 20 20 + # Build the Rust static library before linking. The xcframework is produced 21 21 + # by `scripts/build-ios.sh` and dropped into `ios/RockboxExpo.xcframework`. 22 22 + s.vendored_frameworks = 'RockboxExpo.xcframework' 23 23 + s.libraries = 'c++', 'resolv' 24 24 + 25 25 + s.pod_target_xcconfig = { 26 26 + 'DEFINES_MODULE' => 'YES', 27 27 + 'SWIFT_COMPILATION_MODE' => 'wholemodule', 28 28 + } 29 29 + 30 30 + s.source_files = 'RockboxRpcModule.swift' 31 31 + end

+436

expo/modules/rockbox-rpc/ios/RockboxRpcModule.swift

reviewed

··· 1 1 + import ExpoModulesCore 2 2 + import Foundation 3 3 + 4 4 + // C symbols exported by the rockbox_expo Rust crate (built from 5 5 + // `crates/expo/`). The static library is linked via the .podspec. 6 6 + @_silgen_name("rb_set_server_url") private func rb_set_server_url(_ url: UnsafePointer<CChar>) -> Int32 7 7 + @_silgen_name("rb_ping") private func rb_ping() -> Int32 8 8 + @_silgen_name("rb_play") private func rb_play() -> Int32 9 9 + @_silgen_name("rb_pause") private func rb_pause() -> Int32 10 10 + @_silgen_name("rb_play_pause") private func rb_play_pause() -> Int32 11 11 + @_silgen_name("rb_next") private func rb_next() -> Int32 12 12 + @_silgen_name("rb_prev") private func rb_prev() -> Int32 13 13 + @_silgen_name("rb_seek") private func rb_seek(_ positionMs: Int32) -> Int32 14 14 + @_silgen_name("rb_status_json") private func rb_status_json() -> UnsafeMutablePointer<CChar>? 15 15 + @_silgen_name("rb_current_track_json") private func rb_current_track_json() -> UnsafeMutablePointer<CChar>? 16 16 + @_silgen_name("rb_like_track") private func rb_like_track(_ id: UnsafePointer<CChar>) -> Int32 17 17 + @_silgen_name("rb_unlike_track") private func rb_unlike_track(_ id: UnsafePointer<CChar>) -> Int32 18 18 + @_silgen_name("rb_free_string") private func rb_free_string(_ ptr: UnsafeMutablePointer<CChar>?) 19 19 + 20 20 + @_silgen_name("rb_subscribe_status") private func rb_subscribe_status() -> Int32 21 21 + @_silgen_name("rb_subscribe_current_track") private func rb_subscribe_current_track() -> Int32 22 22 + @_silgen_name("rb_subscribe_playlist") private func rb_subscribe_playlist() -> Int32 23 23 + @_silgen_name("rb_subscribe_library") private func rb_subscribe_library() -> Int32 24 24 + @_silgen_name("rb_subscribe_discovery") private func rb_subscribe_discovery(_ name: UnsafePointer<CChar>) -> Int32 25 25 + @_silgen_name("rb_rockbox_service_name") private func rb_rockbox_service_name() -> UnsafeMutablePointer<CChar>? 26 26 + @_silgen_name("rb_chromecast_service_name") private func rb_chromecast_service_name() -> UnsafeMutablePointer<CChar>? 27 27 + @_silgen_name("rb_poll_event") private func rb_poll_event(_ subId: Int32, _ timeoutMs: Int32) -> UnsafeMutablePointer<CChar>? 28 28 + @_silgen_name("rb_unsubscribe") private func rb_unsubscribe(_ subId: Int32) -> Int32 29 29 + 30 30 + @_silgen_name("rb_resume_track") private func rb_resume_track() -> Int32 31 31 + @_silgen_name("rb_playlist_resume") private func rb_playlist_resume() -> Int32 32 32 + @_silgen_name("rb_play_all_tracks") private func rb_play_all_tracks() -> Int32 33 33 + @_silgen_name("rb_play_track") private func rb_play_track(_ p: UnsafePointer<CChar>) -> Int32 34 34 + @_silgen_name("rb_play_album") private func rb_play_album(_ id: UnsafePointer<CChar>, _ shuffle: Int32) -> Int32 35 35 + @_silgen_name("rb_play_artist_tracks") private func rb_play_artist_tracks(_ id: UnsafePointer<CChar>, _ shuffle: Int32) -> Int32 36 36 + @_silgen_name("rb_play_directory") private func rb_play_directory(_ p: UnsafePointer<CChar>, _ shuffle: Int32, _ position: Int32) -> Int32 37 37 + 38 38 + @_silgen_name("rb_jump_to_queue_position") private func rb_jump_to_queue_position(_ p: Int32) -> Int32 39 39 + @_silgen_name("rb_shuffle_playlist") private func rb_shuffle_playlist() -> Int32 40 40 + @_silgen_name("rb_insert_tracks") private func rb_insert_tracks(_ paths: UnsafePointer<CChar>, _ pos: Int32, _ shuffle: Int32) -> Int32 41 41 + @_silgen_name("rb_insert_track_next") private func rb_insert_track_next(_ p: UnsafePointer<CChar>) -> Int32 42 42 + @_silgen_name("rb_insert_track_last") private func rb_insert_track_last(_ p: UnsafePointer<CChar>) -> Int32 43 43 + @_silgen_name("rb_insert_directory") private func rb_insert_directory(_ p: UnsafePointer<CChar>, _ pos: Int32) -> Int32 44 44 + @_silgen_name("rb_remove_from_queue") private func rb_remove_from_queue(_ pos: Int32) -> Int32 45 45 + @_silgen_name("rb_get_playlist_current_json") private func rb_get_playlist_current_json() -> UnsafeMutablePointer<CChar>? 46 46 + 47 47 + @_silgen_name("rb_get_tracks_json") private func rb_get_tracks_json() -> UnsafeMutablePointer<CChar>? 48 48 + @_silgen_name("rb_get_artists_json") private func rb_get_artists_json() -> UnsafeMutablePointer<CChar>? 49 49 + @_silgen_name("rb_get_album_json") private func rb_get_album_json(_ id: UnsafePointer<CChar>) -> UnsafeMutablePointer<CChar>? 50 50 + @_silgen_name("rb_get_liked_tracks_json") private func rb_get_liked_tracks_json() -> UnsafeMutablePointer<CChar>? 51 51 + @_silgen_name("rb_search_json") private func rb_search_json(_ term: UnsafePointer<CChar>) -> UnsafeMutablePointer<CChar>? 52 52 + 53 53 + @_silgen_name("rb_adjust_volume") private func rb_adjust_volume(_ steps: Int32) -> Int32 54 54 + @_silgen_name("rb_sound_current_json") private func rb_sound_current_json(_ setting: Int32) -> UnsafeMutablePointer<CChar>? 55 55 + 56 56 + @_silgen_name("rb_save_shuffle") private func rb_save_shuffle(_ enabled: Int32) -> Int32 57 57 + @_silgen_name("rb_save_repeat") private func rb_save_repeat(_ mode: Int32) -> Int32 58 58 + @_silgen_name("rb_get_global_settings_json") private func rb_get_global_settings_json() -> UnsafeMutablePointer<CChar>? 59 59 + @_silgen_name("rb_get_global_status_json") private func rb_get_global_status_json() -> UnsafeMutablePointer<CChar>? 60 60 + 61 61 + @_silgen_name("rb_tree_get_entries_json") private func rb_tree_get_entries_json(_ p: UnsafePointer<CChar>?) -> UnsafeMutablePointer<CChar>? 62 62 + 63 63 + @_silgen_name("rb_get_saved_playlists_json") private func rb_get_saved_playlists_json() -> UnsafeMutablePointer<CChar>? 64 64 + @_silgen_name("rb_create_saved_playlist") private func rb_create_saved_playlist(_ name: UnsafePointer<CChar>, _ desc: UnsafePointer<CChar>?, _ ids: UnsafePointer<CChar>?) -> Int32 65 65 + @_silgen_name("rb_update_saved_playlist") private func rb_update_saved_playlist(_ id: UnsafePointer<CChar>, _ name: UnsafePointer<CChar>, _ desc: UnsafePointer<CChar>?) -> Int32 66 66 + @_silgen_name("rb_delete_saved_playlist") private func rb_delete_saved_playlist(_ id: UnsafePointer<CChar>) -> Int32 67 67 + @_silgen_name("rb_add_track_to_playlist") private func rb_add_track_to_playlist(_ pid: UnsafePointer<CChar>, _ tid: UnsafePointer<CChar>) -> Int32 68 68 + @_silgen_name("rb_remove_track_from_playlist") private func rb_remove_track_from_playlist(_ pid: UnsafePointer<CChar>, _ tid: UnsafePointer<CChar>) -> Int32 69 69 + @_silgen_name("rb_get_saved_playlist_tracks_json") private func rb_get_saved_playlist_tracks_json(_ pid: UnsafePointer<CChar>) -> UnsafeMutablePointer<CChar>? 70 70 + @_silgen_name("rb_play_saved_playlist") private func rb_play_saved_playlist(_ pid: UnsafePointer<CChar>) -> Int32 71 71 + 72 72 + @_silgen_name("rb_get_smart_playlists_json") private func rb_get_smart_playlists_json() -> UnsafeMutablePointer<CChar>? 73 73 + @_silgen_name("rb_get_smart_playlist_tracks_json") private func rb_get_smart_playlist_tracks_json(_ id: UnsafePointer<CChar>) -> UnsafeMutablePointer<CChar>? 74 74 + @_silgen_name("rb_play_smart_playlist") private func rb_play_smart_playlist(_ id: UnsafePointer<CChar>) -> Int32 75 75 + 76 76 + @_silgen_name("rb_bluetooth_available") private func rb_bluetooth_available() -> Int32 77 77 + @_silgen_name("rb_get_bluetooth_devices_json") private func rb_get_bluetooth_devices_json() -> UnsafeMutablePointer<CChar>? 78 78 + @_silgen_name("rb_connect_bluetooth") private func rb_connect_bluetooth(_ a: UnsafePointer<CChar>) -> Int32 79 79 + @_silgen_name("rb_disconnect_bluetooth") private func rb_disconnect_bluetooth(_ a: UnsafePointer<CChar>) -> Int32 80 80 + 81 81 + private func takeString(_ ptr: UnsafeMutablePointer<CChar>?) -> String? { 82 82 + guard let ptr = ptr else { return nil } 83 83 + let s = String(cString: ptr) 84 84 + rb_free_string(ptr) 85 85 + return s 86 86 + } 87 87 + 88 88 + private func parseJson(_ s: String?) throws -> Any { 89 89 + guard let s = s, let data = s.data(using: .utf8) else { 90 90 + throw NSError(domain: "RockboxRpc", code: -1, userInfo: [NSLocalizedDescriptionKey: "no response"]) 91 91 + } 92 92 + let obj = try JSONSerialization.jsonObject(with: data, options: []) 93 93 + if let dict = obj as? [String: Any], let err = dict["error"] as? String { 94 94 + throw NSError(domain: "RockboxRpc", code: -2, userInfo: [NSLocalizedDescriptionKey: err]) 95 95 + } 96 96 + return obj 97 97 + } 98 98 + 99 99 + public class RockboxRpcModule: Module { 100 100 + private let pollQueue = DispatchQueue(label: "rockbox.rpc.poll", qos: .utility, attributes: .concurrent) 101 101 + private var pollTokens: [Int32: Bool] = [:] // subId → keepRunning 102 102 + private let pollLock = NSLock() 103 103 + 104 104 + public func definition() -> ModuleDefinition { 105 105 + Name("RockboxRpc") 106 106 + 107 107 + Events( 108 108 + "rockbox.status", 109 109 + "rockbox.currentTrack", 110 110 + "rockbox.playlist", 111 111 + "rockbox.library", 112 112 + "rockbox.discovery", 113 113 + "rockbox.error" 114 114 + ) 115 115 + 116 116 + Function("rockboxServiceName") { () -> String in 117 117 + takeString(rb_rockbox_service_name()) ?? "_rockbox._tcp.local." 118 118 + } 119 119 + Function("chromecastServiceName") { () -> String in 120 120 + takeString(rb_chromecast_service_name()) ?? "_googlecast._tcp.local." 121 121 + } 122 122 + 123 123 + Function("setServerUrl") { (url: String) in 124 124 + url.withCString { _ = rb_set_server_url($0) } 125 125 + } 126 126 + 127 127 + AsyncFunction("ping") { () -> Bool in 128 128 + return rb_ping() == 0 129 129 + } 130 130 + 131 131 + AsyncFunction("play") { () -> Void in if rb_play() != 0 { throw playbackError("play") } } 132 132 + AsyncFunction("pause") { () -> Void in if rb_pause() != 0 { throw playbackError("pause") } } 133 133 + AsyncFunction("playPause") { () -> Void in if rb_play_pause() != 0 { throw playbackError("playPause") } } 134 134 + AsyncFunction("next") { () -> Void in if rb_next() != 0 { throw playbackError("next") } } 135 135 + AsyncFunction("prev") { () -> Void in if rb_prev() != 0 { throw playbackError("prev") } } 136 136 + AsyncFunction("seek") { (positionMs: Int) -> Void in 137 137 + if rb_seek(Int32(positionMs)) != 0 { throw playbackError("seek") } 138 138 + } 139 139 + 140 140 + AsyncFunction("status") { () -> [String: Any] in 141 141 + let s = takeString(rb_status_json()) 142 142 + guard let dict = try parseJson(s) as? [String: Any] else { 143 143 + throw playbackError("status") 144 144 + } 145 145 + return dict 146 146 + } 147 147 + 148 148 + AsyncFunction("currentTrack") { () -> [String: Any] in 149 149 + let s = takeString(rb_current_track_json()) 150 150 + guard let dict = try parseJson(s) as? [String: Any] else { 151 151 + throw playbackError("currentTrack") 152 152 + } 153 153 + return dict 154 154 + } 155 155 + 156 156 + AsyncFunction("likeTrack") { (id: String) -> Void in 157 157 + let rc = id.withCString { rb_like_track($0) } 158 158 + if rc != 0 { throw playbackError("likeTrack") } 159 159 + } 160 160 + 161 161 + AsyncFunction("unlikeTrack") { (id: String) -> Void in 162 162 + let rc = id.withCString { rb_unlike_track($0) } 163 163 + if rc != 0 { throw playbackError("unlikeTrack") } 164 164 + } 165 165 + 166 166 + // ── Comprehensive RPC surface ─────────────────────────────────────── 167 167 + AsyncFunction("resumeTrack") { () -> Void in if rb_resume_track() != 0 { throw self.playbackError("resumeTrack") } } 168 168 + AsyncFunction("playlistResume") { () -> Void in if rb_playlist_resume() != 0 { throw self.playbackError("playlistResume") } } 169 169 + AsyncFunction("playAllTracks") { () -> Void in if rb_play_all_tracks() != 0 { throw self.playbackError("playAllTracks") } } 170 170 + 171 171 + AsyncFunction("playTrack") { (path: String) -> Void in 172 172 + let rc = path.withCString { rb_play_track($0) } 173 173 + if rc != 0 { throw self.playbackError("playTrack") } 174 174 + } 175 175 + AsyncFunction("playAlbum") { (id: String, shuffle: Bool) -> Void in 176 176 + let rc = id.withCString { rb_play_album($0, shuffle ? 1 : 0) } 177 177 + if rc != 0 { throw self.playbackError("playAlbum") } 178 178 + } 179 179 + AsyncFunction("playArtistTracks") { (id: String, shuffle: Bool) -> Void in 180 180 + let rc = id.withCString { rb_play_artist_tracks($0, shuffle ? 1 : 0) } 181 181 + if rc != 0 { throw self.playbackError("playArtistTracks") } 182 182 + } 183 183 + AsyncFunction("playDirectory") { (path: String, shuffle: Bool, position: Int) -> Void in 184 184 + let rc = path.withCString { rb_play_directory($0, shuffle ? 1 : 0, Int32(position)) } 185 185 + if rc != 0 { throw self.playbackError("playDirectory") } 186 186 + } 187 187 + 188 188 + AsyncFunction("jumpToQueuePosition") { (pos: Int) -> Void in 189 189 + if rb_jump_to_queue_position(Int32(pos)) != 0 { throw self.playbackError("jumpToQueuePosition") } 190 190 + } 191 191 + AsyncFunction("shufflePlaylist") { () -> Void in 192 192 + if rb_shuffle_playlist() != 0 { throw self.playbackError("shufflePlaylist") } 193 193 + } 194 194 + AsyncFunction("insertTracks") { (paths: [String], position: Int, shuffle: Bool) -> Void in 195 195 + let json = (try? JSONSerialization.data(withJSONObject: paths)) 196 196 + .flatMap { String(data: $0, encoding: .utf8) } ?? "[]" 197 197 + let rc = json.withCString { rb_insert_tracks($0, Int32(position), shuffle ? 1 : 0) } 198 198 + if rc != 0 { throw self.playbackError("insertTracks") } 199 199 + } 200 200 + AsyncFunction("insertTrackNext") { (path: String) -> Void in 201 201 + let rc = path.withCString { rb_insert_track_next($0) } 202 202 + if rc != 0 { throw self.playbackError("insertTrackNext") } 203 203 + } 204 204 + AsyncFunction("insertTrackLast") { (path: String) -> Void in 205 205 + let rc = path.withCString { rb_insert_track_last($0) } 206 206 + if rc != 0 { throw self.playbackError("insertTrackLast") } 207 207 + } 208 208 + AsyncFunction("insertDirectory") { (path: String, position: Int) -> Void in 209 209 + let rc = path.withCString { rb_insert_directory($0, Int32(position)) } 210 210 + if rc != 0 { throw self.playbackError("insertDirectory") } 211 211 + } 212 212 + AsyncFunction("removeFromQueue") { (pos: Int) -> Void in 213 213 + if rb_remove_from_queue(Int32(pos)) != 0 { throw self.playbackError("removeFromQueue") } 214 214 + } 215 215 + 216 216 + AsyncFunction("getPlaylistCurrent") { () -> Any in 217 217 + try self.parseJsonOrThrow(takeString(rb_get_playlist_current_json()), op: "getPlaylistCurrent") 218 218 + } 219 219 + AsyncFunction("getTracks") { () -> Any in 220 220 + try self.parseJsonOrThrow(takeString(rb_get_tracks_json()), op: "getTracks") 221 221 + } 222 222 + AsyncFunction("getArtists") { () -> Any in 223 223 + try self.parseJsonOrThrow(takeString(rb_get_artists_json()), op: "getArtists") 224 224 + } 225 225 + AsyncFunction("getAlbum") { (id: String) -> Any in 226 226 + let raw = id.withCString { rb_get_album_json($0) } 227 227 + return try self.parseJsonOrThrow(takeString(raw), op: "getAlbum") 228 228 + } 229 229 + AsyncFunction("getLikedTracks") { () -> Any in 230 230 + try self.parseJsonOrThrow(takeString(rb_get_liked_tracks_json()), op: "getLikedTracks") 231 231 + } 232 232 + AsyncFunction("search") { (term: String) -> Any in 233 233 + let raw = term.withCString { rb_search_json($0) } 234 234 + return try self.parseJsonOrThrow(takeString(raw), op: "search") 235 235 + } 236 236 + 237 237 + AsyncFunction("adjustVolume") { (steps: Int) -> Void in 238 238 + if rb_adjust_volume(Int32(steps)) != 0 { throw self.playbackError("adjustVolume") } 239 239 + } 240 240 + AsyncFunction("soundCurrent") { (setting: Int) -> Any in 241 241 + try self.parseJsonOrThrow(takeString(rb_sound_current_json(Int32(setting))), op: "soundCurrent") 242 242 + } 243 243 + 244 244 + AsyncFunction("saveShuffle") { (enabled: Bool) -> Void in 245 245 + if rb_save_shuffle(enabled ? 1 : 0) != 0 { throw self.playbackError("saveShuffle") } 246 246 + } 247 247 + AsyncFunction("saveRepeat") { (mode: Int) -> Void in 248 248 + if rb_save_repeat(Int32(mode)) != 0 { throw self.playbackError("saveRepeat") } 249 249 + } 250 250 + AsyncFunction("getGlobalSettings") { () -> Any in 251 251 + try self.parseJsonOrThrow(takeString(rb_get_global_settings_json()), op: "getGlobalSettings") 252 252 + } 253 253 + AsyncFunction("getGlobalStatus") { () -> Any in 254 254 + try self.parseJsonOrThrow(takeString(rb_get_global_status_json()), op: "getGlobalStatus") 255 255 + } 256 256 + 257 257 + AsyncFunction("treeGetEntries") { (path: String?) -> Any in 258 258 + let raw: UnsafeMutablePointer<CChar>? 259 259 + if let p = path { 260 260 + raw = p.withCString { rb_tree_get_entries_json($0) } 261 261 + } else { 262 262 + raw = rb_tree_get_entries_json(nil) 263 263 + } 264 264 + return try self.parseJsonOrThrow(takeString(raw), op: "treeGetEntries") 265 265 + } 266 266 + 267 267 + AsyncFunction("getSavedPlaylists") { () -> Any in 268 268 + try self.parseJsonOrThrow(takeString(rb_get_saved_playlists_json()), op: "getSavedPlaylists") 269 269 + } 270 270 + AsyncFunction("createSavedPlaylist") { (name: String, description: String?, trackIds: [String]) -> Void in 271 271 + let idsJson = (try? JSONSerialization.data(withJSONObject: trackIds)) 272 272 + .flatMap { String(data: $0, encoding: .utf8) } ?? "[]" 273 273 + let rc: Int32 = name.withCString { namePtr in 274 274 + idsJson.withCString { idsPtr in 275 275 + if let d = description { 276 276 + return d.withCString { descPtr in rb_create_saved_playlist(namePtr, descPtr, idsPtr) } 277 277 + } else { 278 278 + return rb_create_saved_playlist(namePtr, nil, idsPtr) 279 279 + } 280 280 + } 281 281 + } 282 282 + if rc != 0 { throw self.playbackError("createSavedPlaylist") } 283 283 + } 284 284 + AsyncFunction("updateSavedPlaylist") { (id: String, name: String, description: String?) -> Void in 285 285 + let rc: Int32 = id.withCString { idPtr in 286 286 + name.withCString { namePtr in 287 287 + if let d = description { 288 288 + return d.withCString { descPtr in rb_update_saved_playlist(idPtr, namePtr, descPtr) } 289 289 + } else { 290 290 + return rb_update_saved_playlist(idPtr, namePtr, nil) 291 291 + } 292 292 + } 293 293 + } 294 294 + if rc != 0 { throw self.playbackError("updateSavedPlaylist") } 295 295 + } 296 296 + AsyncFunction("deleteSavedPlaylist") { (id: String) -> Void in 297 297 + let rc = id.withCString { rb_delete_saved_playlist($0) } 298 298 + if rc != 0 { throw self.playbackError("deleteSavedPlaylist") } 299 299 + } 300 300 + AsyncFunction("addTrackToPlaylist") { (playlistId: String, trackId: String) -> Void in 301 301 + let rc: Int32 = playlistId.withCString { pid in 302 302 + trackId.withCString { tid in rb_add_track_to_playlist(pid, tid) } 303 303 + } 304 304 + if rc != 0 { throw self.playbackError("addTrackToPlaylist") } 305 305 + } 306 306 + AsyncFunction("removeTrackFromPlaylist") { (playlistId: String, trackId: String) -> Void in 307 307 + let rc: Int32 = playlistId.withCString { pid in 308 308 + trackId.withCString { tid in rb_remove_track_from_playlist(pid, tid) } 309 309 + } 310 310 + if rc != 0 { throw self.playbackError("removeTrackFromPlaylist") } 311 311 + } 312 312 + AsyncFunction("getSavedPlaylistTracks") { (playlistId: String) -> Any in 313 313 + let raw = playlistId.withCString { rb_get_saved_playlist_tracks_json($0) } 314 314 + return try self.parseJsonOrThrow(takeString(raw), op: "getSavedPlaylistTracks") 315 315 + } 316 316 + AsyncFunction("playSavedPlaylist") { (playlistId: String) -> Void in 317 317 + let rc = playlistId.withCString { rb_play_saved_playlist($0) } 318 318 + if rc != 0 { throw self.playbackError("playSavedPlaylist") } 319 319 + } 320 320 + 321 321 + AsyncFunction("getSmartPlaylists") { () -> Any in 322 322 + try self.parseJsonOrThrow(takeString(rb_get_smart_playlists_json()), op: "getSmartPlaylists") 323 323 + } 324 324 + AsyncFunction("getSmartPlaylistTracks") { (id: String) -> Any in 325 325 + let raw = id.withCString { rb_get_smart_playlist_tracks_json($0) } 326 326 + return try self.parseJsonOrThrow(takeString(raw), op: "getSmartPlaylistTracks") 327 327 + } 328 328 + AsyncFunction("playSmartPlaylist") { (id: String) -> Void in 329 329 + let rc = id.withCString { rb_play_smart_playlist($0) } 330 330 + if rc != 0 { throw self.playbackError("playSmartPlaylist") } 331 331 + } 332 332 + 333 333 + AsyncFunction("bluetoothAvailable") { () -> Bool in 334 334 + return rb_bluetooth_available() == 1 335 335 + } 336 336 + AsyncFunction("getBluetoothDevices") { () -> Any in 337 337 + try self.parseJsonOrThrow(takeString(rb_get_bluetooth_devices_json()), op: "getBluetoothDevices") 338 338 + } 339 339 + AsyncFunction("connectBluetooth") { (address: String) -> Void in 340 340 + let rc = address.withCString { rb_connect_bluetooth($0) } 341 341 + if rc != 0 { throw self.playbackError("connectBluetooth") } 342 342 + } 343 343 + AsyncFunction("disconnectBluetooth") { (address: String) -> Void in 344 344 + let rc = address.withCString { rb_disconnect_bluetooth($0) } 345 345 + if rc != 0 { throw self.playbackError("disconnectBluetooth") } 346 346 + } 347 347 + 348 348 + // ── Streaming subscriptions ───────────────────────────────────────── 349 349 + Function("subscribeStatus") { () -> Int32 in 350 350 + let id = rb_subscribe_status() 351 351 + self.startPollLoop(subId: id, eventName: "rockbox.status") 352 352 + return id 353 353 + } 354 354 + Function("subscribeCurrentTrack") { () -> Int32 in 355 355 + let id = rb_subscribe_current_track() 356 356 + self.startPollLoop(subId: id, eventName: "rockbox.currentTrack") 357 357 + return id 358 358 + } 359 359 + Function("subscribePlaylist") { () -> Int32 in 360 360 + let id = rb_subscribe_playlist() 361 361 + self.startPollLoop(subId: id, eventName: "rockbox.playlist") 362 362 + return id 363 363 + } 364 364 + Function("subscribeLibrary") { () -> Int32 in 365 365 + let id = rb_subscribe_library() 366 366 + self.startPollLoop(subId: id, eventName: "rockbox.library") 367 367 + return id 368 368 + } 369 369 + Function("subscribeDiscovery") { (serviceName: String) -> Int32 in 370 370 + let id = serviceName.withCString { rb_subscribe_discovery($0) } 371 371 + self.startPollLoop(subId: id, eventName: "rockbox.discovery") 372 372 + return id 373 373 + } 374 374 + Function("unsubscribe") { (subId: Int32) -> Void in 375 375 + self.pollLock.lock() 376 376 + self.pollTokens[subId] = false 377 377 + self.pollLock.unlock() 378 378 + _ = rb_unsubscribe(subId) 379 379 + } 380 380 + } 381 381 + 382 382 + private func startPollLoop(subId: Int32, eventName: String) { 383 383 + pollLock.lock() 384 384 + pollTokens[subId] = true 385 385 + pollLock.unlock() 386 386 + 387 387 + pollQueue.async { [weak self] in 388 388 + while true { 389 389 + guard let self = self else { return } 390 390 + self.pollLock.lock() 391 391 + let alive = self.pollTokens[subId] ?? false 392 392 + self.pollLock.unlock() 393 393 + if !alive { return } 394 394 + 395 395 + guard let raw = rb_poll_event(subId, 1_000) else { 396 396 + // Timeout (no event in 1s) — keep polling. 397 397 + continue 398 398 + } 399 399 + let s = String(cString: raw) 400 400 + rb_free_string(raw) 401 401 + guard let data = s.data(using: .utf8), 402 402 + let obj = try? JSONSerialization.jsonObject(with: data) else { 403 403 + continue 404 404 + } 405 405 + if let dict = obj as? [String: Any] { 406 406 + if let err = dict["error"] as? String { 407 407 + self.sendEvent("rockbox.error", ["subId": subId, "error": err, "stream": eventName]) 408 408 + // Stop polling after an error. 409 409 + self.pollLock.lock() 410 410 + self.pollTokens[subId] = false 411 411 + self.pollLock.unlock() 412 412 + return 413 413 + } 414 414 + self.sendEvent(eventName, dict) 415 415 + } 416 416 + } 417 417 + } 418 418 + } 419 419 + 420 420 + private func playbackError(_ op: String) -> NSError { 421 421 + return NSError(domain: "RockboxRpc", code: -1, 422 422 + userInfo: [NSLocalizedDescriptionKey: "rockbox-rpc: \(op) failed"]) 423 423 + } 424 424 + 425 425 + fileprivate func parseJsonOrThrow(_ s: String?, op: String) throws -> Any { 426 426 + guard let s = s, let data = s.data(using: .utf8) else { 427 427 + throw playbackError(op) 428 428 + } 429 429 + let obj = try JSONSerialization.jsonObject(with: data, options: .allowFragments) 430 430 + if let dict = obj as? [String: Any], let err = dict["error"] as? String { 431 431 + throw NSError(domain: "RockboxRpc", code: -2, 432 432 + userInfo: [NSLocalizedDescriptionKey: "rockbox-rpc: \(op): \(err)"]) 433 433 + } 434 434 + return obj 435 435 + } 436 436 + }

+18

expo/modules/rockbox-rpc/package.json

reviewed

··· 1 1 + { 2 2 + "name": "rockbox-rpc", 3 3 + "version": "0.1.0", 4 4 + "description": "Native gRPC client for the rockboxd daemon (wraps the rockbox-expo Rust crate)", 5 5 + "main": "src/index.ts", 6 6 + "types": "src/index.ts", 7 7 + "private": true, 8 8 + "keywords": ["rockbox", "expo", "grpc"], 9 9 + "scripts": { 10 10 + "build:ios": "./scripts/build-ios.sh", 11 11 + "build:android": "./scripts/build-android.sh" 12 12 + }, 13 13 + "peerDependencies": { 14 14 + "expo": "*", 15 15 + "react": "*", 16 16 + "react-native": "*" 17 17 + } 18 18 + }

+28

expo/modules/rockbox-rpc/scripts/build-android.sh

reviewed

··· 1 1 + #!/usr/bin/env bash 2 2 + # Build the rockbox-expo Rust cdylib for Android via cargo-ndk and drop the 3 3 + # resulting .so files under android/src/main/jniLibs/<abi>/. 4 4 + # 5 5 + # Prereqs: 6 6 + # cargo install cargo-ndk 7 7 + # rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android 8 8 + # ANDROID_NDK_HOME must point at a valid NDK r25+ install. 9 9 + set -euo pipefail 10 10 + 11 11 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 12 12 + MODULE_DIR="$(dirname "$SCRIPT_DIR")" 13 13 + WORKSPACE_ROOT="$(cd "$MODULE_DIR/../../.." && pwd)" 14 14 + 15 15 + PROFILE=${PROFILE:-release} 16 16 + JNILIBS="$MODULE_DIR/android/src/main/jniLibs" 17 17 + mkdir -p "$JNILIBS" 18 18 + 19 19 + cd "$WORKSPACE_ROOT" 20 20 + cargo ndk \ 21 21 + -t arm64-v8a \ 22 22 + -t armeabi-v7a \ 23 23 + -t x86_64 \ 24 24 + -o "$JNILIBS" \ 25 25 + build -p rockbox-expo $( [[ "$PROFILE" == "release" ]] && echo "--release" ) 26 26 + 27 27 + echo 28 28 + echo "Built $JNILIBS/<abi>/librockbox_expo.so"

+73

expo/modules/rockbox-rpc/scripts/build-ios.sh

reviewed

··· 1 1 + #!/usr/bin/env bash 2 2 + # Build the rockbox-expo Rust static lib for iOS device + simulator and pack 3 3 + # them into an .xcframework consumed by the Pod. 4 4 + # 5 5 + # Required Rust targets (install once): 6 6 + # rustup target add aarch64-apple-ios aarch64-apple-ios-sim x86_64-apple-ios 7 7 + # 8 8 + # Output: expo/modules/rockbox-rpc/ios/RockboxExpo.xcframework 9 9 + set -euo pipefail 10 10 + 11 11 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 12 12 + MODULE_DIR="$(dirname "$SCRIPT_DIR")" 13 13 + WORKSPACE_ROOT="$(cd "$MODULE_DIR/../../.." && pwd)" 14 14 + 15 15 + LIB_NAME="librockbox_expo.a" 16 16 + PROFILE=${PROFILE:-release} 17 17 + CARGO_FLAGS=() 18 18 + if [[ "$PROFILE" == "release" ]]; then 19 19 + CARGO_FLAGS+=(--release) 20 20 + fi 21 21 + 22 22 + # 1. Build for each iOS target 23 23 + ( cd "$WORKSPACE_ROOT" && cargo build -p rockbox-expo "${CARGO_FLAGS[@]}" --target aarch64-apple-ios ) 24 24 + ( cd "$WORKSPACE_ROOT" && cargo build -p rockbox-expo "${CARGO_FLAGS[@]}" --target aarch64-apple-ios-sim ) 25 25 + ( cd "$WORKSPACE_ROOT" && cargo build -p rockbox-expo "${CARGO_FLAGS[@]}" --target x86_64-apple-ios ) 26 26 + 27 27 + DEVICE_LIB="$WORKSPACE_ROOT/target/aarch64-apple-ios/$PROFILE/$LIB_NAME" 28 28 + SIM_ARM_LIB="$WORKSPACE_ROOT/target/aarch64-apple-ios-sim/$PROFILE/$LIB_NAME" 29 29 + SIM_X86_LIB="$WORKSPACE_ROOT/target/x86_64-apple-ios/$PROFILE/$LIB_NAME" 30 30 + 31 31 + # 2. Create a fat simulator slice (arm64 + x86_64) 32 32 + SIM_FAT_DIR="$WORKSPACE_ROOT/target/ios-sim-fat" 33 33 + mkdir -p "$SIM_FAT_DIR" 34 34 + SIM_FAT_LIB="$SIM_FAT_DIR/$LIB_NAME" 35 35 + lipo -create "$SIM_ARM_LIB" "$SIM_X86_LIB" -output "$SIM_FAT_LIB" 36 36 + 37 37 + # 3. Pack into an xcframework with a tiny module map so Swift can `import` it 38 38 + HEADERS_DIR="$MODULE_DIR/ios/headers" 39 39 + mkdir -p "$HEADERS_DIR" 40 40 + cat > "$HEADERS_DIR/RockboxExpo.h" <<'HDR' 41 41 + #pragma once 42 42 + #include <stdint.h> 43 43 + 44 44 + int32_t rb_set_server_url(const char *url); 45 45 + int32_t rb_ping(void); 46 46 + int32_t rb_play(void); 47 47 + int32_t rb_pause(void); 48 48 + int32_t rb_play_pause(void); 49 49 + int32_t rb_next(void); 50 50 + int32_t rb_prev(void); 51 51 + int32_t rb_seek(int32_t position_ms); 52 52 + char *rb_status_json(void); 53 53 + char *rb_current_track_json(void); 54 54 + int32_t rb_like_track(const char *id); 55 55 + int32_t rb_unlike_track(const char *id); 56 56 + void rb_free_string(char *ptr); 57 57 + HDR 58 58 + cat > "$HEADERS_DIR/module.modulemap" <<'MODMAP' 59 59 + module RockboxExpo { 60 60 + header "RockboxExpo.h" 61 61 + export * 62 62 + } 63 63 + MODMAP 64 64 + 65 65 + OUT="$MODULE_DIR/ios/RockboxExpo.xcframework" 66 66 + rm -rf "$OUT" 67 67 + xcodebuild -create-xcframework \ 68 68 + -library "$DEVICE_LIB" -headers "$HEADERS_DIR" \ 69 69 + -library "$SIM_FAT_LIB" -headers "$HEADERS_DIR" \ 70 70 + -output "$OUT" 71 71 + 72 72 + echo 73 73 + echo "Built $OUT"

+192

expo/modules/rockbox-rpc/src/index.ts

reviewed

··· 1 1 + import { requireNativeModule } from "expo"; 2 2 + import type { EventSubscription } from "expo-modules-core"; 3 3 + 4 4 + /** 5 5 + * Track snapshot returned by `currentTrack()`. Mirrors the JSON shape 6 6 + * produced by `rb_current_track_json` in `crates/expo/src/lib.rs`. 7 7 + */ 8 8 + export type TrackSnapshot = { 9 9 + id: string; 10 10 + path: string; 11 11 + title: string; 12 12 + artist: string; 13 13 + album: string; 14 14 + album_art?: string | null; 15 15 + duration_ms: number; 16 16 + elapsed_ms: number; 17 17 + }; 18 18 + 19 19 + /** 20 20 + * Server playback status. Numeric codes mirror the rockbox internal status 21 21 + * enum: 0 = stopped, 1 = playing, 2 = paused. 22 22 + */ 23 23 + export type StatusSnapshot = { 24 24 + status: 0 | 1 | 2; 25 25 + }; 26 26 + 27 27 + /** Streamed playlist snapshot (queue position + tracks). */ 28 28 + export type PlaylistSnapshot = { 29 29 + index: number; 30 30 + amount: number; 31 31 + tracks: TrackSnapshot[]; 32 32 + }; 33 33 + 34 34 + export type StreamErrorEvent = { 35 35 + subId: number; 36 36 + stream: 37 37 + | "rockbox.status" 38 38 + | "rockbox.currentTrack" 39 39 + | "rockbox.playlist" 40 40 + | "rockbox.library" 41 41 + | "rockbox.discovery"; 42 42 + error: string; 43 43 + }; 44 44 + 45 45 + /** 46 46 + * One resolved service from the mDNS discovery stream. Mirrors the JSON shape 47 47 + * produced by `rb_subscribe_discovery` in `crates/expo`. 48 48 + */ 49 49 + export type DiscoveredService = { 50 50 + name: string; 51 51 + fullname: string; 52 52 + hostname: string; 53 53 + port: number; 54 54 + addresses: string[]; 55 55 + properties: Record<string, string>; 56 56 + }; 57 57 + 58 58 + /** Event payload map. Matches `Events(...)` declared in the native modules. */ 59 59 + export type RockboxRpcEvents = { 60 60 + "rockbox.status": (s: StatusSnapshot) => void; 61 61 + "rockbox.currentTrack": (t: TrackSnapshot) => void; 62 62 + "rockbox.playlist": (p: PlaylistSnapshot) => void; 63 63 + "rockbox.library": (l: unknown) => void; 64 64 + "rockbox.discovery": (s: DiscoveredService) => void; 65 65 + "rockbox.error": (e: StreamErrorEvent) => void; 66 66 + }; 67 67 + 68 68 + // Loose JSON shapes — proto messages are returned as-is. These are unknowns 69 69 + // because the proto types aren't generated on the JS side; consumers can cast 70 70 + // or define their own row types as needed. 71 71 + export type Json = unknown; 72 72 + 73 73 + type RockboxRpcNative = { 74 74 + /** Configure the gRPC server URL. Call once at app startup. */ 75 75 + setServerUrl(url: string): void; 76 76 + /** Round-trip Status RPC; resolves with `true` if the server replied. */ 77 77 + ping(): Promise<boolean>; 78 78 + 79 79 + // Playback 80 80 + play(): Promise<void>; 81 81 + pause(): Promise<void>; 82 82 + playPause(): Promise<void>; 83 83 + next(): Promise<void>; 84 84 + prev(): Promise<void>; 85 85 + seek(positionMs: number): Promise<void>; 86 86 + 87 87 + // Read 88 88 + status(): Promise<StatusSnapshot>; 89 89 + currentTrack(): Promise<TrackSnapshot>; 90 90 + 91 91 + // Library 92 92 + likeTrack(id: string): Promise<void>; 93 93 + unlikeTrack(id: string): Promise<void>; 94 94 + 95 95 + // Playback (extended) 96 96 + resumeTrack(): Promise<void>; 97 97 + playlistResume(): Promise<void>; 98 98 + playAllTracks(): Promise<void>; 99 99 + playTrack(path: string): Promise<void>; 100 100 + playAlbum(albumId: string, shuffle: boolean): Promise<void>; 101 101 + playArtistTracks(artistId: string, shuffle: boolean): Promise<void>; 102 102 + playDirectory( 103 103 + path: string, 104 104 + shuffle: boolean, 105 105 + /** -1 to omit; otherwise zero-based start position */ 106 106 + position: number, 107 107 + ): Promise<void>; 108 108 + 109 109 + // Queue 110 110 + jumpToQueuePosition(pos: number): Promise<void>; 111 111 + shufflePlaylist(): Promise<void>; 112 112 + insertTracks(paths: string[], position: number, shuffle: boolean): Promise<void>; 113 113 + insertTrackNext(path: string): Promise<void>; 114 114 + insertTrackLast(path: string): Promise<void>; 115 115 + insertDirectory(path: string, position: number): Promise<void>; 116 116 + removeFromQueue(pos: number): Promise<void>; 117 117 + getPlaylistCurrent(): Promise<Json>; 118 118 + 119 119 + // Library 120 120 + getTracks(): Promise<Json>; 121 121 + getArtists(): Promise<Json>; 122 122 + getAlbum(id: string): Promise<Json>; 123 123 + getLikedTracks(): Promise<Json>; 124 124 + search(term: string): Promise<Json>; 125 125 + 126 126 + // Sound 127 127 + adjustVolume(steps: number): Promise<void>; 128 128 + soundCurrent(setting: number): Promise<Json>; 129 129 + 130 130 + // Settings 131 131 + saveShuffle(enabled: boolean): Promise<void>; 132 132 + saveRepeat(mode: number): Promise<void>; 133 133 + getGlobalSettings(): Promise<Json>; 134 134 + getGlobalStatus(): Promise<Json>; 135 135 + 136 136 + // Browse 137 137 + treeGetEntries(path: string | null): Promise<Json>; 138 138 + 139 139 + // Saved playlists 140 140 + getSavedPlaylists(): Promise<Json>; 141 141 + createSavedPlaylist( 142 142 + name: string, 143 143 + description: string | null, 144 144 + trackIds: string[], 145 145 + ): Promise<void>; 146 146 + updateSavedPlaylist( 147 147 + id: string, 148 148 + name: string, 149 149 + description: string | null, 150 150 + ): Promise<void>; 151 151 + deleteSavedPlaylist(id: string): Promise<void>; 152 152 + addTrackToPlaylist(playlistId: string, trackId: string): Promise<void>; 153 153 + removeTrackFromPlaylist(playlistId: string, trackId: string): Promise<void>; 154 154 + getSavedPlaylistTracks(playlistId: string): Promise<Json>; 155 155 + playSavedPlaylist(playlistId: string): Promise<void>; 156 156 + 157 157 + // Smart playlists 158 158 + getSmartPlaylists(): Promise<Json>; 159 159 + getSmartPlaylistTracks(id: string): Promise<Json>; 160 160 + playSmartPlaylist(id: string): Promise<void>; 161 161 + 162 162 + // Bluetooth 163 163 + bluetoothAvailable(): Promise<boolean>; 164 164 + getBluetoothDevices(): Promise<Json>; 165 165 + connectBluetooth(address: string): Promise<void>; 166 166 + disconnectBluetooth(address: string): Promise<void>; 167 167 + 168 168 + // Streaming subscriptions — return an opaque numeric subscription id. 169 169 + // Pair with `unsubscribe(id)` to tear down. Events fire on the registered 170 170 + // listener channels (see `RockboxRpcEvents`). 171 171 + subscribeStatus(): number; 172 172 + subscribeCurrentTrack(): number; 173 173 + subscribePlaylist(): number; 174 174 + subscribeLibrary(): number; 175 175 + subscribeDiscovery(serviceName: string): number; 176 176 + unsubscribe(subId: number): void; 177 177 + 178 178 + // mDNS / Bonjour service-name constants exported by `rockbox-discovery`. 179 179 + rockboxServiceName(): string; 180 180 + chromecastServiceName(): string; 181 181 + 182 182 + // Event API (provided by Expo Modules' EventEmitter base). 183 183 + addListener<K extends keyof RockboxRpcEvents>( 184 184 + event: K, 185 185 + listener: RockboxRpcEvents[K], 186 186 + ): EventSubscription; 187 187 + removeAllListeners(event: keyof RockboxRpcEvents): void; 188 188 + }; 189 189 + 190 190 + const RockboxRpc = requireNativeModule<RockboxRpcNative>("RockboxRpc"); 191 191 + 192 192 + export default RockboxRpc;

+5 -2

expo/package.json

reviewed

··· 9 9 "ios": "expo run:ios", 10 10 "web": "expo start --web", 11 11 "lint": "expo lint", 12 12 - "run:android": "expo run:android" 12 12 + "run:android": "expo run:android", 13 13 + "postinstall": "node ./scripts/link-rockbox-rpc.js", 14 14 + "adb:reverse": "adb reverse tcp:8081 tcp:8081" 13 15 }, 14 16 "dependencies": { 15 17 "@expo/vector-icons": "^15.0.3", ··· 39 41 "react-native-safe-area-context": "~5.6.0", 40 42 "react-native-screens": "~4.16.0", 41 43 "react-native-web": "~0.21.0", 42 42 - "react-native-worklets": "0.5.1" 44 44 + "react-native-worklets": "0.5.1", 45 45 + "rockbox-rpc": "file:./modules/rockbox-rpc" 43 46 }, 44 47 "devDependencies": { 45 48 "@types/react": "~19.1.0",

+40

expo/scripts/link-rockbox-rpc.js

reviewed

··· 1 1 + #!/usr/bin/env node 2 2 + // Replace `node_modules/rockbox-rpc` with a symlink to `modules/rockbox-rpc`. 3 3 + // 4 4 + // Bun resolves `"file:./modules/rockbox-rpc"` by *copying* the directory into 5 5 + // `node_modules`, which means edits to the source module aren't visible until 6 6 + // you re-run `bun install`. We need a live symlink so TS picks up new exports 7 7 + // and Metro picks up native module changes immediately. This runs as the 8 8 + // `postinstall` hook so every install converges on the symlinked layout. 9 9 + 10 10 + const fs = require("node:fs"); 11 11 + const path = require("node:path"); 12 12 + 13 13 + const expoRoot = path.resolve(__dirname, ".."); 14 14 + const target = path.join(expoRoot, "node_modules", "rockbox-rpc"); 15 15 + const source = path.join(expoRoot, "modules", "rockbox-rpc"); 16 16 + const relativeSource = path.relative(path.dirname(target), source); 17 17 + 18 18 + if (!fs.existsSync(source)) { 19 19 + console.warn(`[link-rockbox-rpc] source missing: ${source}`); 20 20 + process.exit(0); 21 21 + } 22 22 + 23 23 + // Skip if it's already the right symlink. 24 24 + try { 25 25 + const stat = fs.lstatSync(target); 26 26 + if (stat.isSymbolicLink()) { 27 27 + const current = fs.readlinkSync(target); 28 28 + if (path.resolve(path.dirname(target), current) === source) { 29 29 + console.log("[link-rockbox-rpc] already linked → ok"); 30 30 + process.exit(0); 31 31 + } 32 32 + } 33 33 + fs.rmSync(target, { recursive: true, force: true }); 34 34 + } catch (err) { 35 35 + if (err.code !== "ENOENT") throw err; 36 36 + } 37 37 + 38 38 + fs.mkdirSync(path.dirname(target), { recursive: true }); 39 39 + fs.symlinkSync(relativeSource, target, "dir"); 40 40 + console.log(`[link-rockbox-rpc] linked ${target} → ${relativeSource}`);