fix(bluetooth): recover source slot during stream (2026.6.23.2-9853)

Author: RealWhyKnot

bridge/src/cmd_run.rs

@@ -593,15 +593,11 @@ fn selected_pico_xinput_source_error(instance_ids: &[String]) -> String {
 }
 
 async fn wait_for_bluetooth_source_slots(routes: &mut [StreamRoute], quiet: bool) -> Result<()> {
-    let bluetooth_route_count = routes
-        .iter()
-        .filter(|route| route.pico.persona.is_bluetooth())
-        .count();
-    if bluetooth_route_count == 0 {
+    if !routes.iter().any(|route| route.pico.persona.is_bluetooth()) {
         return Ok(());
     }
 
-    let allow_auto_switch = bluetooth_route_count == 1;
+    let allow_auto_switch = should_auto_switch_bluetooth_source(routes);
     let deadline = Instant::now() + BLUETOOTH_SOURCE_WAIT;
     let mut announced_wait = false;
     loop {
@@ -723,6 +719,10 @@ fn bluetooth_source_slot_decision(
     BluetoothSourceSlotDecision::Missing
 }
 
+fn should_auto_switch_bluetooth_source(routes: &[StreamRoute]) -> bool {
+    routes.len() == 1 && routes[0].pico.persona.is_bluetooth()
+}
+
 #[derive(Clone, Debug)]
 struct MissingBluetoothSource {
     pico_uid: String,
@@ -822,11 +822,12 @@ pub async fn stream_routes(routes: Vec<StreamRoute>, options: StreamOptions) ->
         print_stream_intro(&routes, socket.local_addr()?);
     }
 
+    let allow_bluetooth_source_auto_switch = should_auto_switch_bluetooth_source(&routes);
     let mut runtime: Vec<RouteRuntime> = routes
         .into_iter()
         .map(|route| {
             let bluetooth_usb = bluetooth_usb_links.remove(&route.pico.info.unique_id_short);
-            RouteRuntime::new(route, bluetooth_usb)
+            RouteRuntime::new(route, bluetooth_usb, allow_bluetooth_source_auto_switch)
         })
         .collect();
     // Bring the injected-input keyboard hook up before the first tick so a
@@ -972,14 +973,21 @@ struct RouteRuntime {
     last_key: protocol::KeyboardReport,
     last_packet_number: Option<u32>,
     source_connected: bool,
+    allow_source_auto_switch: bool,
+    source_auto_switch_count: u32,
+    last_source_auto_switch: Option<String>,
     last_send_type: &'static str,
     last_recovery_attempt: Option<Instant>,
     recovery_hint_printed: bool,
     bluetooth_pairing_hint_printed: bool,
 }
 
 impl RouteRuntime {
-    fn new(route: StreamRoute, bluetooth_usb: Option<cdc::PicoSetup>) -> Self {
+    fn new(
+        route: StreamRoute,
+        bluetooth_usb: Option<cdc::PicoSetup>,
+        allow_source_auto_switch: bool,
+    ) -> Self {
         Self {
             route,
             bluetooth_usb,
@@ -996,6 +1004,9 @@ impl RouteRuntime {
             last_key: protocol::KeyboardReport::default(),
             last_packet_number: None,
             source_connected: false,
+            allow_source_auto_switch,
+            source_auto_switch_count: 0,
+            last_source_auto_switch: None,
             last_send_type: "heartbeat",
             last_recovery_attempt: None,
             recovery_hint_printed: false,
@@ -1069,7 +1080,8 @@ impl RouteRuntime {
     }
 
     fn next_controller_packet(&mut self) -> Packet {
-        let source = xinput::read_slot(self.route.source_slot);
+        let source = xinput::read_slot(self.route.source_slot)
+            .or_else(|| self.try_auto_switch_bluetooth_source());
         let (state, packet_number, connected) = match source {
             Some(snapshot) => (snapshot.state, Some(snapshot.packet_number), true),
             None => (GamepadState::default(), None, false),
@@ -1091,6 +1103,40 @@ impl RouteRuntime {
         packet
     }
 
+    fn try_auto_switch_bluetooth_source(&mut self) -> Option<xinput::SlotSnapshot> {
+        if !self.allow_source_auto_switch || !self.route.pico.persona.is_bluetooth() {
+            return None;
+        }
+        let connected = xinput::connected_slots();
+        let BluetoothSourceSlotDecision::AutoSwitch { from, to } =
+            bluetooth_source_slot_decision(self.route.source_slot, &connected, true)
+        else {
+            return None;
+        };
+        let snapshot = connected
+            .iter()
+            .find(|snapshot| snapshot.slot == to)
+            .copied()?;
+        self.route.source_slot = to;
+        self.source_auto_switch_count = self.source_auto_switch_count.saturating_add(1);
+        self.last_source_auto_switch = Some(format!(
+            "{} -> {}",
+            xinput::user_slot_label(from),
+            xinput::user_slot_label(to)
+        ));
+        self.last_packet_number = None;
+        self.source_connected = false;
+        tracing::warn!(
+            "stream: Bluetooth source auto-switched during stream pico={} from {} to {} packet={} {}",
+            self.route.pico.uid_hex(),
+            xinput::user_slot_label(from),
+            xinput::user_slot_label(to),
+            snapshot.packet_number,
+            format_xinput_snapshot(&snapshot)
+        );
+        Some(snapshot)
+    }
+
     fn next_keyboard_packet(&mut self) -> Packet {
         let report = keyboard::read_keyboard();
         // The host keyboard is always present in the Parsec model, so the
@@ -1269,16 +1315,27 @@ fn print_status(routes: &mut [RouteRuntime]) {
                     sent_delta: Some(sent_delta),
                     last_inbound_ms_ago,
                     source_connected: Some(route.source_connected),
+                    source_auto_switch_count: Some(route.source_auto_switch_count),
+                    last_source_auto_switch: route.last_source_auto_switch.clone(),
                     last_send_type: Some(route.last_send_type.to_string()),
                 }),
         );
+        let source_switch_note = match (
+            route.source_auto_switch_count,
+            route.last_source_auto_switch.as_deref(),
+        ) {
+            (0, _) => String::new(),
+            (count, Some(last)) => format!(" | source auto-switches {count} last {last}"),
+            (count, None) => format!(" | source auto-switches {count}"),
+        };
         if bluetooth_route {
             println!(
-                "  {} -> {} ({}) | {} | PC USB input +{} total {} | Bluetooth output {} | {} {}",
+                "  {} -> {} ({}) | {}{} | PC USB input +{} total {} | Bluetooth output {} | {} {}",
                 route.route.source_label(),
                 route.route.pico.uid_hex(),
                 route.route.pico.persona.label(),
                 source_state,
+                source_switch_note,
                 sent_delta,
                 route.sent_total,
                 peer_state,
@@ -1287,10 +1344,11 @@ fn print_status(routes: &mut [RouteRuntime]) {
             );
         } else {
             println!(
-                "  {} -> {} | {} | out +{} total {} | in {} ({}) | {} {}",
+                "  {} -> {} | {}{} | out +{} total {} | in {} ({}) | {} {}",
                 route.route.source_label(),
                 route.route.pico.uid_hex(),
                 source_state,
+                source_switch_note,
                 sent_delta,
                 route.sent_total,
                 route.inbound_total,

bridge/src/cmd_run/tests.rs

@@ -188,6 +188,28 @@ fn bluetooth_source_slot_decision_refuses_ambiguous_or_absent_source() {
     );
 }
 
+#[test]
+fn bluetooth_source_auto_switch_only_allows_single_bluetooth_route() {
+    let mut bluetooth = pico(0x07D37EB6, "192.168.50.226", protocol::BOARD_PICO_2_W);
+    bluetooth.persona = Persona::BluetoothHid;
+    let xinput = pico(0x523861E6, "192.168.50.4", protocol::BOARD_PICO_W_RP2040);
+
+    assert!(should_auto_switch_bluetooth_source(&[StreamRoute {
+        source_slot: 1,
+        pico: bluetooth.clone(),
+    }]));
+    assert!(!should_auto_switch_bluetooth_source(&[
+        StreamRoute {
+            source_slot: 1,
+            pico: bluetooth,
+        },
+        StreamRoute {
+            source_slot: 0,
+            pico: xinput,
+        },
+    ]));
+}
+
 #[test]
 fn bluetooth_source_preflight_error_lists_live_slots() {
     let message = bluetooth_source_preflight_error(&[MissingBluetoothSource {
@@ -213,13 +235,15 @@ fn debug_packet_harvest_targets_only_include_enabled_debug_routes() {
                 pico: debug,
             },
             None,
+            false,
         ),
         RouteRuntime::new(
             StreamRoute {
                 source_slot: 1,
                 pico: xinput,
             },
             None,
+            false,
         ),
     ];
 
@@ -289,6 +313,7 @@ fn bluetooth_routes_do_not_schedule_udp_recovery() {
             pico: bt,
         },
         None,
+        true,
     )];
     routes[0].last_inbound = Instant::now() - (PEER_STALE_AFTER + Duration::from_secs(1));
 

bridge/src/pico_cache.rs

@@ -102,6 +102,8 @@ pub struct RouteSnapshot {
     pub sent_delta: Option<u64>,
     pub last_inbound_ms_ago: Option<u64>,
     pub source_connected: Option<bool>,
+    pub source_auto_switch_count: Option<u32>,
+    pub last_source_auto_switch: Option<String>,
     pub last_send_type: Option<String>,
 }
 

pico-bridge/src/bt_hid.c

@@ -262,6 +262,10 @@ static void request_send_now(bool force) {
     hid_device_request_can_send_now_event(bt_hid_cid);
 }
 
+void bt_hid_request_send_now(bool force) {
+    request_send_now(force);
+}
+
 static void send_pending_report(void) {
     uint8_t interrupt_report[BT_HID_INTERRUPT_REPORT_LEN];
     if (bt_hid_pending_report.len > BT_HID_MAX_WIRE_REPORT_LEN)

pico-bridge/src/bt_hid.h

@@ -86,5 +86,6 @@ typedef struct {
 bool bt_hid_target_from_persona(run_persona_t persona, bt_hid_target_t *out);
 bool bt_hid_init(bt_hid_target_t target);
 void bt_hid_reset_stack_state(void);
+void bt_hid_request_send_now(bool force);
 void bt_hid_snapshot(bt_hid_snapshot_t *out);
 void bt_hid_task(void);

pico-bridge/src/cdc_handlers.c

@@ -33,6 +33,9 @@ static uint32_t bt_cdc_last_heartbeat_ms;
 static uint8_t bt_cdc_last_seq;
 static uint8_t bt_cdc_last_command;
 static uint8_t bt_cdc_last_flags;
+static bool bt_cdc_logged_first_frame;
+static bool bt_cdc_logged_parsec_connected;
+static bool bt_cdc_logged_non_neutral;
 
 static void write_cdc_frame(const uint8_t *frame, size_t n) {
     if (!frame || n == 0)
@@ -168,7 +171,18 @@ static size_t handle_reboot_to_bootsel(uint8_t seq, uint8_t *reply, size_t cap)
     return cdc_encode(CDC_RSP_REBOOT_TO_BOOTSEL, seq, NULL, 0, reply, cap);
 }
 
-static void apply_bt_state_body(const uint8_t *payload) {
+static bool bt_state_body_non_neutral(const uint8_t *payload) {
+    const uint8_t *body = &payload[1];
+    for (size_t i = 0; i < 12; i++) {
+        if (body[i] != 0)
+            return true;
+    }
+    return false;
+}
+
+static bool apply_bt_state_body(const uint8_t *payload) {
+    gamepad_state_t previous = g_gamepad_state;
+    int previous_parsec_connected = g_parsec_connected;
     const uint8_t flags = payload[0];
     const uint8_t *body = &payload[1];
     g_gamepad_state.buttons = (uint16_t)body[0] | ((uint16_t)body[1] << 8);
@@ -180,6 +194,13 @@ static void apply_bt_state_body(const uint8_t *payload) {
     g_gamepad_state.right_y = (int16_t)((uint16_t)body[10] | ((uint16_t)body[11] << 8));
     g_parsec_connected = (flags & 0x01u) ? 1 : 0;
     g_last_packet_ms = to_ms_since_boot(get_absolute_time());
+    return previous.buttons != g_gamepad_state.buttons ||
+           previous.left_trigger != g_gamepad_state.left_trigger ||
+           previous.right_trigger != g_gamepad_state.right_trigger ||
+           previous.left_x != g_gamepad_state.left_x || previous.left_y != g_gamepad_state.left_y ||
+           previous.right_x != g_gamepad_state.right_x ||
+           previous.right_y != g_gamepad_state.right_y ||
+           previous_parsec_connected != g_parsec_connected;
 }
 
 static void note_bt_cdc_frame(const cdc_frame_view_t *req) {
@@ -190,6 +211,27 @@ static void note_bt_cdc_frame(const cdc_frame_view_t *req) {
     bt_cdc_last_flags = req->payload_len > 0 ? req->payload[0] : 0;
 }
 
+static void log_bt_cdc_frame_milestones(const cdc_frame_view_t *req, bool changed) {
+    if (!bt_cdc_logged_first_frame) {
+        diag_log_printf("cdc: first Bluetooth input cmd=0x%02X seq=%u flags=0x%02X",
+                        (unsigned)req->command, (unsigned)req->seq, (unsigned)bt_cdc_last_flags);
+        bt_cdc_logged_first_frame = true;
+    }
+    if (!bt_cdc_logged_parsec_connected && (bt_cdc_last_flags & 0x01u)) {
+        diag_log_printf("cdc: Bluetooth input source connected seq=%u", (unsigned)req->seq);
+        bt_cdc_logged_parsec_connected = true;
+    }
+    if (!bt_cdc_logged_non_neutral && bt_state_body_non_neutral(req->payload)) {
+        const uint8_t *body = &req->payload[1];
+        uint16_t buttons = (uint16_t)body[0] | ((uint16_t)body[1] << 8);
+        diag_log_printf(
+            "cdc: Bluetooth input non-neutral seq=%u changed=%u buttons=0x%04X lt=%u rt=%u",
+            (unsigned)req->seq, changed ? 1u : 0u, (unsigned)buttons, (unsigned)body[2],
+            (unsigned)body[3]);
+        bt_cdc_logged_non_neutral = true;
+    }
+}
+
 static size_t handle_bt_state(const cdc_frame_view_t *req, uint8_t *reply, size_t cap) {
     note_bt_cdc_frame(req);
     if (boot_mode_current() != BOOT_MODE_RUN ||
@@ -210,7 +252,10 @@ static size_t handle_bt_state(const cdc_frame_view_t *req, uint8_t *reply, size_
         bt_cdc_heartbeat_count++;
         bt_cdc_last_heartbeat_ms = bt_cdc_last_frame_ms;
     }
-    apply_bt_state_body(req->payload);
+    bool changed = apply_bt_state_body(req->payload);
+    log_bt_cdc_frame_milestones(req, changed);
+    if (changed)
+        bt_hid_request_send_now(true);
     return 0;
 }
 
@@ -443,6 +488,9 @@ void cdc_handlers_init(void) {
     bt_cdc_last_seq = 0;
     bt_cdc_last_command = 0;
     bt_cdc_last_flags = 0;
+    bt_cdc_logged_first_frame = false;
+    bt_cdc_logged_parsec_connected = false;
+    bt_cdc_logged_non_neutral = false;
 }
 
 bool cdc_handlers_reboot_pending(void) {