feat(remote): add remote control settings

.cargo/mutants.toml

@@ -1,3 +1,3 @@
 # SPDX-License-Identifier: GPL-3.0-only
 # Copyright (C) 2026 Max Boksem. See NOTICE for additional terms under GPLv3 section 7.
 
@@ -72,6 +72,10 @@
     # Asks macOS whether it refuses local network access. On Linux, where
     # the mutation runs build, it's always false.
     'src-tauri/src/cast/mod\.rs:.*\blocal_network_denied\b',
+    # These bind remote control's real port and advertise this machine on the
+    # network. The tests start the target on loopback with start_on instead.
+    'src-tauri/src/remote/service\.rs:.*\b(start|advertise_on_network)\b',
+    'src-tauri/src/remote/target\.rs:.*\bbind_default\b',
 ]
 
 # Without --in-place, cargo-mutants copies the tree to build each mutant. This

CHANGELOG.md

@@ -8,6 +8,7 @@ All notable changes to Cinette, formerly called Max Video Player, are listed her
 
 - On iPhone and iPad, the player has an AirPlay button when an AirPlay TV is in reach. It sends the channel, movie or episode that's playing to the TV, which plays it straight from your provider, and a movie or episode carries on from where it was. Streams the TV can't play as they are, such as MKV files and most raw MPEG-TS channels, stay on the iPhone and Cinette says why (#323).
 - The player answers a keyboard's media keys. Play/pause, play and pause work as you'd expect, fast forward and rewind skip by the lengths set in Settings, and next and previous change the episode (#312).
+- On macOS and Linux, one Cinette can control another on the same network. Choose Devices in the sidebar and pick the other device; it plays there, and this one shows what's playing, with play, pause, stop and that device's channels, movies and series to choose from. Under Only when allowed, the default, the other device asks first, and both screens show the same code so you can tell your own request from someone else's. Settings > Remote control sets whether others can find this device, who may control it (Always allow, Only when allowed, Never allow), its name, lists the devices controlling it, each with Disconnect, and can give this device a new identity, which ends every session. macOS asks once whether Cinette may use the local network; if that was refused, the device list says where to allow it. Nothing leaves your network, and no stream address, login or playlist setting is sent to the other device (#317, #318, #319, #321, #322).
 
 ### Changed
 

apps/player/src-tauri/Cargo.toml

@@ -25,6 +25,8 @@ chrono = { version = "0.4", features = ["serde"] }
 reqwest = { workspace = true, features = ["json", "stream"] }
 futures-util = "0.3"
 tempfile = "3"
+# Reads the logo addresses other Cinette devices send. The same version as mvp-core's.
+url = "2"
 
 [dev-dependencies]
 # The mock runtime, so tests can build an app and call commands without a window.
@@ -42,10 +44,19 @@ libc = "0.2"
 zbus = "5"
 # DNS-SD for Cinette devices and Cast receivers, without needing Avahi.
 mdns-sd = { version = "0.21", default-features = false }
+# The interfaces' subnets, so remote control only takes local peers. The
+# same version as mdns-sd's.
+if-addrs = "0.15"
+# The remote-control listener's dual-stack socket. The same version as tokio's.
+socket2 = "0.6"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 # poll and the socket types for Bonjour's dns_sd.h.
 libc = "0.2"
+# The interfaces' subnets, so remote control only takes local peers.
+if-addrs = "0.15"
+# The remote-control listener's dual-stack socket. The same version as tokio's.
+socket2 = "0.6"
 
 [target.'cfg(target_os = "ios")'.dependencies]
 oslog = { version = "0.2", default-features = false }

apps/player/src-tauri/Info.plist

@@ -8,7 +8,7 @@
 		<true/>
 	</dict>
 	<key>NSLocalNetworkUsageDescription</key>
-	<string>Cinette finds Chromecasts, TVs and other Cinette devices on your local network so you can play on them.</string>
+	<string>Cinette finds Chromecasts, TVs and other Cinette devices on your local network, so you can play on them or control them.</string>
 	<key>NSBonjourServices</key>
 	<array>
 		<string>_cinette._tcp</string>

apps/player/src-tauri/src/commands.rs

@@ -309,15 +309,24 @@ pub async fn update_provider(
 pub async fn get_xtream_series_episodes(
     state: State<'_, AppState>,
     channel_id: String,
+) -> Result<Vec<Channel>, String> {
+    fetch_series_episodes(&state.cache, &channel_id).await
+}
+
+/// The episodes of the Xtream series `channel_id`, from its provider. The
+/// cache is only locked while the series and its provider are read.
+pub(crate) async fn fetch_series_episodes(
+    cache: &Mutex<CacheStore>,
+    channel_id: &str,
 ) -> Result<Vec<Channel>, String> {
     let (channel, provider) = {
-        let cache = state.cache.lock().map_err(|e| e.to_string())?;
+        let cache = cache.lock().map_err(|e| e.to_string())?;
         let ch = cache
-            .get_channel_by_id(&channel_id)
+            .get_channel_by_id(channel_id)
             .map_err(|e| e.to_string())?
             .ok_or_else(|| format!("Channel not found: {channel_id}"))?;
         let p = cache
-            .get_provider_for_channel(&channel_id)
+            .get_provider_for_channel(channel_id)
             .map_err(|e| e.to_string())?
             .ok_or("Provider not found for channel")?;
         (ch, p)

apps/player/src-tauri/src/commands/tests/arguments.json

@@ -107,5 +107,21 @@
 	},
 	"stop_recording": { "required": ["id"] },
 	"get_cast_receivers": {},
-	"hold_cast_receivers": { "required": ["ids"] }
+	"hold_cast_receivers": { "required": ["ids"] },
+	"remote_get_settings": {},
+	"remote_set_settings": { "required": ["settings"] },
+	"remote_reset_identity": {},
+	"remote_answer_consent": { "required": ["request", "allow"] },
+	"remote_sessions": {},
+	"remote_pending_consent": {},
+	"remote_disconnect": { "required": ["sessionId"] },
+	"remote_set_state": { "required": ["state"] },
+	"remote_finish_command": { "required": ["token", "outcome"] },
+	"remote_devices": {},
+	"remote_local_network_denied": {},
+	"remote_connect": { "required": ["deviceId", "link"] },
+	"remote_link": {},
+	"remote_leave": { "required": ["link"] },
+	"remote_command": { "required": ["command", "link"] },
+	"remote_catalog": { "required": ["catalogQuery", "link"] }
 }

apps/player/src-tauri/src/commands/tests/mod.rs

@@ -197,7 +197,16 @@ fn sample(argument: &str) -> Value {
         | "source" | "generation" => {
             json!(1)
         }
-        "keep" => json!(true),
+        "keep" | "allow" => json!(true),
+        "request" | "token" => json!(1),
+        "outcome" => json!("ok"),
+        "command" => json!({ "action": "stop" }),
+        "catalogQuery" => json!({ "kind": "groups", "contentType": "live", "limit": 100 }),
+        "settings" => json!({ "discoverable": true, "remoteControl": "ask", "deviceName": null }),
+        "state" => json!({
+            "status": "idle", "item": null, "position": 0, "duration": 0, "volume": null,
+            "subtitleId": null, "audioId": null, "error": null
+        }),
         "episode" | "channel" => serde_json::to_value(Channel::default()).unwrap(),
         _ => json!("x"),
     }

apps/player/src-tauri/src/lib.rs

@@ -16,6 +16,7 @@
 mod identifier;
 mod logging;
 mod progress;
+mod remote;
 mod streams;
 #[cfg(test)]
 mod android_project_tests;
@@ -25,6 +26,7 @@
 mod test_support;
 
 use commands::AppState;
+use remote::commands as remote_commands;
 use mvp_core::cache::store::CacheStore;
 use std::sync::Mutex;
 use tauri::Manager;
@@ -144,6 +146,22 @@
 }
 
 register_commands![
+    remote_commands::remote_get_settings,
+    remote_commands::remote_set_settings,
+    remote_commands::remote_reset_identity,
+    remote_commands::remote_answer_consent,
+    remote_commands::remote_sessions,
+    remote_commands::remote_pending_consent,
+    remote_commands::remote_disconnect,
+    remote_commands::remote_set_state,
+    remote_commands::remote_finish_command,
+    remote_commands::remote_devices,
+    remote_commands::remote_local_network_denied,
+    remote_commands::remote_connect,
+    remote_commands::remote_link,
+    remote_commands::remote_leave,
+    remote_commands::remote_command,
+    remote_commands::remote_catalog,
     commands::load_m3u_playlist,
     commands::load_m3u_file,
     commands::load_xtream_provider,
@@ -356,66 +374,72 @@
             app.manage(crate::streams::StreamsState::default());
             crate::downloads::manager::restore_settings(app.handle());
 
+            // Listens for other Cinette devices and advertises this one.
+            #[cfg(any(target_os = "linux", target_os = "macos"))]
+            crate::remote::start(app.handle(), app_dir.clone());
+
             #[cfg(desktop)]
             {
                 use tauri_plugin_shell::ShellExt;
                 crate::downloads::retention::start(app.handle());
                 match app.shell().sidecar(crate::downloads::FFMPEG_SIDECAR) {
                     Ok(_) => {
                         tracing::info!("ffmpeg sidecar resolved");
                         // Start or miss the recordings that came due while the
                         // app was closed, before downloads take the connections.
                         let next_check = crate::downloads::recordings::run_check(app.handle());
                         crate::downloads::recordings::start(app.handle(), next_check);
                         // Start whatever is still queued from the last run.
                         if let Err(e) = crate::downloads::manager::pump(app.handle()) {
                             tracing::warn!("Failed to start queued downloads: {e}");
                         }
                     }
                     Err(e) => tracing::error!("ffmpeg sidecar missing: {e}"),
                 }
             }
 
             // Set the WebView's native background to fully transparent so the
             // video surface (positioned below the WebView) is visible through it.
             // CSS `background: transparent` alone is not sufficient on all Linux
             // compositors (e.g. Pop!_OS/COSMIC with WebKit2GTK DMABUF renderer).
             #[cfg(any(target_os = "macos", target_os = "linux"))]
             if let Some(ref window) = app.get_webview_window("main") {
                 use tauri::webview::Color;
                 if let Err(e) = window.set_background_color(Some(Color(0, 0, 0, 0))) {
                     tracing::warn!("Failed to set WebView background transparent: {}", e);
                 }
             }
 
             #[cfg(debug_assertions)]
             {
                 let window = app.get_webview_window("main").unwrap();
                 window.open_devtools();
             }
 
             #[cfg(any(target_os = "macos", target_os = "linux"))]
             {
                 if let Some(window) = app.get_webview_window("main") {
                     let handle = app.handle().clone();
                     window.on_window_event(move |event| {
                         if let tauri::WindowEvent::Resized(size) = event
                             && let Some(state) = handle.try_state::<tauri_plugin_mpv::MpvState>()
                         {
                             state.resize(size.width, size.height);
                         }
                     });
                 }
             }
 
             Ok(())
         })
         .build(context)
         .expect("error while building tauri application")
         .run(|app, event| {
             if let tauri::RunEvent::Exit = event {
                 crate::downloads::manager::stop_all_for_exit(app);
                 crate::downloads::recordings::stop_all_for_exit(app);
+                #[cfg(any(target_os = "linux", target_os = "macos"))]
+                crate::remote::stop_for_exit(app);
             }
         });
 }