refactor: clean connection status

Signed-off-by: Haobo Gu <haobogu@outlook.com>

Author: HaoboGu

rmk/src/ble/mod.rs

@@ -23,7 +23,7 @@ use crate::ble::profile::{ProfileInfo, ProfileManager, UPDATED_CCCD_TABLE, UPDAT
 use crate::channel::{BLE_REPORT_CHANNEL, LED_SIGNAL};
 use crate::config::RmkConfig;
 use crate::core_traits::Runnable;
-use crate::event::{ConnectionChangeEvent, SubscribableEvent, publish_event};
+use crate::event::SubscribableEvent;
 use crate::hid::{HidWriterTrait, run_led_reader};
 #[cfg(feature = "split")]
 use crate::split::ble::central::CENTRAL_SLEEP;
@@ -87,7 +87,6 @@ where
     pub async fn new(stack: &'a Stack<'a, C, DefaultPacketPool>, rmk_config: RmkConfig<'static>) -> Self {
         let preferred = crate::state::load_preferred_connection().await;
         crate::state::set_preferred_connection(preferred);
-        publish_event(ConnectionChangeEvent::new(preferred));
 
         let mut profile_manager = ProfileManager::new(stack);
         #[cfg(feature = "storage")]
@@ -741,7 +740,7 @@ mod tests {
     use rmk_types::ble::{BleState, BleStatus};
 
     use crate::event::{Axis, AxisEvent, AxisValType, KeyboardEvent, PointingEvent, SubscribableEvent, publish_event};
-    use crate::state::{connection_status, set_ble_profile, set_ble_state};
+    use crate::state::{current_ble_status, set_ble_profile, set_ble_state};
     use crate::test_support::test_block_on as block_on;
 
     fn ble_status_test_lock() -> &'static Mutex<()> {
@@ -757,7 +756,7 @@ mod tests {
         set_ble_state(BleState::Advertising);
 
         assert_eq!(
-            connection_status().ble,
+            current_ble_status(),
             BleStatus {
                 profile: 2,
                 state: BleState::Advertising,
@@ -774,7 +773,7 @@ mod tests {
         set_ble_profile(3);
 
         assert_eq!(
-            connection_status().ble,
+            current_ble_status(),
             BleStatus {
                 profile: 3,
                 state: BleState::Inactive,

rmk/src/ble/profile.rs

@@ -7,10 +7,7 @@ use embassy_sync::signal::Signal;
 use trouble_host::prelude::*;
 use trouble_host::{BondInformation, LongTermKey};
 #[cfg(feature = "storage")]
-use {
-    crate::channel::FLASH_CHANNEL,
-    crate::storage::{FLASH_OPERATION_FINISHED, FlashOperationMessage},
-};
+use {crate::channel::FLASH_CHANNEL, crate::storage::FLASH_OPERATION_FINISHED};
 
 use super::ble_server::CCCD_TABLE_SIZE;
 use crate::NUM_BLE_PROFILE;
@@ -157,7 +154,6 @@ pub(crate) enum BleProfileAction {
     PreviousProfile,
     NextProfile,
     ClearProfile,
-    ToggleConnection,
 }
 
 /// Manage BLE profiles and bonding information
@@ -387,16 +383,6 @@ impl<'a, C: Controller + ControllerCmdAsync<LeSetPhy>, P: PacketPool> ProfileMan
                         BleProfileAction::ClearProfile => {
                             self.clear_bond(current_profile()).await;
                         }
-                        BleProfileAction::ToggleConnection => {
-                            // Flips the persisted transport preference and lets
-                            // the routing cascade recompute `active`.
-                            let updated = crate::state::toggle_preferred();
-
-                            info!("Switching preferred transport to: {:?}", updated);
-
-                            #[cfg(feature = "storage")]
-                            FLASH_CHANNEL.send(FlashOperationMessage::ConnectionType(updated)).await;
-                        }
                     }
                     #[cfg(feature = "storage")]
                     FLASH_OPERATION_FINISHED.wait().await;

rmk/src/display/mod.rs

@@ -417,6 +417,13 @@ where
         use crate::event::EventSubscriber;
         let mut sub = <Self as Processor>::subscriber();
 
+        // Prime from current state after subscribing, so the first render
+        // reflects state that was set before the processor started.
+        #[cfg(feature = "_ble")]
+        {
+            self.ctx.ble_status = crate::state::current_ble_status();
+        }
+
         self.pending_render = true;
         self.render().await;
         let mut ticker = self.render_interval.map(Ticker::every);

rmk/src/keyboard.rs

@@ -1580,7 +1580,7 @@ impl<'a> Keyboard<'a> {
             if event.pressed {
                 // Clear Peer is processed when pressed
                 if id == NUM_BLE_PROFILE as u8 + 4 {
-                    #[cfg(all(feature = "split", feature = "_ble"))]
+                    #[cfg(feature = "split")]
                     if event.pressed {
                         // Wait for 5s, if the key is still pressed, clear split peer info
                         // If there's any other key event received during this period, skip
@@ -1592,7 +1592,7 @@ impl<'a> Keyboard<'a> {
                         {
                             Either::First(_) => {
                                 // Timeout reached, send clear peer message
-                                #[cfg(all(feature = "split", feature = "_ble"))]
+                                #[cfg(feature = "split")]
                                 publish_event(ClearPeerEvent);
                                 info!("Clear peer");
                             }
@@ -1606,23 +1606,26 @@ impl<'a> Keyboard<'a> {
                     }
                 }
             } else {
-                // Other user keys are processed when released
+                // Other user keys are processed when released.
+                // Slots 0..NUM_BLE_PROFILE select a profile directly; the next four are
+                // fixed actions stacked on top.
                 if id < NUM_BLE_PROFILE as u8 {
                     info!("Switch to profile: {}", id);
-                    // User0~7: Swtich to the specific profile
                     BLE_PROFILE_CHANNEL.send(BleProfileAction::SwitchProfile(id)).await;
                 } else if id == NUM_BLE_PROFILE as u8 {
-                    // User8: Next profile
+                    // Next profile
                     BLE_PROFILE_CHANNEL.send(BleProfileAction::NextProfile).await;
                 } else if id == NUM_BLE_PROFILE as u8 + 1 {
-                    // User9: Previous profile
+                    // Previous profile
                     BLE_PROFILE_CHANNEL.send(BleProfileAction::PreviousProfile).await;
                 } else if id == NUM_BLE_PROFILE as u8 + 2 {
-                    // User10: Clear profile
+                    // Clear profile
                     BLE_PROFILE_CHANNEL.send(BleProfileAction::ClearProfile).await;
                 } else if id == NUM_BLE_PROFILE as u8 + 3 {
-                    // User11:
-                    BLE_PROFILE_CHANNEL.send(BleProfileAction::ToggleConnection).await;
+                    // Toggle preferred transport (USB <-> BLE);
+                    // only meaningful when both transports exist in this build.
+                    #[cfg(not(feature = "_no_usb"))]
+                    crate::state::toggle_preferred().await;
                 }
             }
         }

rmk/src/lib.rs

@@ -193,9 +193,6 @@ pub async fn run_rmk<
 
     #[cfg(all(not(feature = "_ble"), not(feature = "_no_usb")))]
     {
-        crate::event::publish_event(crate::event::ConnectionChangeEvent::new(
-            rmk_types::connection::ConnectionType::Usb,
-        ));
         let mut usb = crate::usb::UsbTransport::new(usb_driver, device_config);
         embassy_futures::join::join(usb.run(), wpm.polling_loop()).await;
     }

rmk/src/state.rs

@@ -3,6 +3,8 @@ use core::sync::atomic::{AtomicBool, Ordering};
 
 use embassy_sync::blocking_mutex::Mutex;
 use rmk_types::ble::BleState;
+#[cfg(feature = "_ble")]
+use rmk_types::ble::BleStatus;
 use rmk_types::connection::{ConnectionStatus, ConnectionType, UsbState};
 
 use crate::RawMutex;
@@ -17,6 +19,12 @@ use crate::event::{ConnectionChangeEvent, publish_event};
 /// is re-established
 static MATRIX_SCAN_OVERRIDE: AtomicBool = AtomicBool::new(false);
 
+/// Single source of truth for transport state and routing. All writes go
+/// through the mutator helpers below so the active-output cascade runs and
+/// change events fire on every transition.
+pub(crate) static CONNECTION_STATUS: Mutex<RawMutex, Cell<ConnectionStatus>> =
+    Mutex::new(Cell::new(ConnectionStatus::new()));
+
 #[cfg(feature = "_ble")]
 pub(crate) fn enable_matrix_scan_override() {
     MATRIX_SCAN_OVERRIDE.store(true, Ordering::Release);
@@ -32,18 +40,17 @@ pub(crate) fn input_processing_ready() -> bool {
     active_transport().is_some() || MATRIX_SCAN_OVERRIDE.load(Ordering::Acquire) || cfg!(not(feature = "_no_usb"))
 }
 
-/// Single source of truth for transport state and routing. All writes go
-/// through the mutator helpers below so the active-output cascade runs and
-/// change events fire on every transition.
-pub(crate) static CONNECTION_STATUS: Mutex<RawMutex, Cell<ConnectionStatus>> =
-    Mutex::new(Cell::new(ConnectionStatus::new()));
-
 pub(crate) fn active_transport() -> Option<ConnectionType> {
-    connection_status().decide_active()
+    CONNECTION_STATUS.lock(|c| c.get().decide_active())
 }
 
-pub(crate) fn connection_status() -> ConnectionStatus {
-    CONNECTION_STATUS.lock(|c| c.get())
+pub(crate) fn current_usb_state() -> UsbState {
+    CONNECTION_STATUS.lock(|c| c.get().usb)
+}
+
+#[cfg(feature = "_ble")]
+pub(crate) fn current_ble_status() -> BleStatus {
+    CONNECTION_STATUS.lock(|c| c.get().ble)
 }
 
 /// Read-modify-write the connection status atomically.
@@ -63,7 +70,7 @@ fn update_status(f: impl FnOnce(&mut ConnectionStatus)) {
 
     let prev_active = prev.decide_active();
     let new_active = new.decide_active();
-    // TODO: Is it really needed?
+
     if prev_active != new_active
         && let Some(prev_active) = prev_active
     {
@@ -82,6 +89,7 @@ fn update_status(f: impl FnOnce(&mut ConnectionStatus)) {
     }
 }
 
+#[cfg(not(feature = "std"))]
 pub fn set_usb_state(s: UsbState) {
     update_status(|c| c.usb = s);
 }
@@ -129,7 +137,8 @@ pub(crate) async fn load_preferred_connection() -> ConnectionType {
     }
 }
 
-pub(crate) fn toggle_preferred() -> ConnectionType {
+#[cfg(all(feature = "_ble", not(feature = "_no_usb")))]
+pub(crate) async fn toggle_preferred() {
     let mut new = ConnectionType::Usb;
     update_status(|c| {
         c.preferred = match c.preferred {
@@ -138,12 +147,16 @@ pub(crate) fn toggle_preferred() -> ConnectionType {
         };
         new = c.preferred;
     });
-    new
+    info!("Switching preferred transport to: {:?}", new);
+    #[cfg(feature = "storage")]
+    crate::channel::FLASH_CHANNEL
+        .send(crate::storage::FlashOperationMessage::ConnectionType(new))
+        .await;
 }
 
 #[cfg(feature = "_ble")]
 pub(crate) fn current_profile() -> u8 {
-    connection_status().ble.profile
+    CONNECTION_STATUS.lock(|c| c.get().ble.profile)
 }
 
 #[cfg(test)]

rmk/src/usb/mod.rs

@@ -23,7 +23,7 @@ use crate::hid::{
     CompositeReport, CompositeReportType, HidError, HidWriterTrait, KeyboardReport, Report, run_led_reader,
 };
 use crate::light::UsbLedReader;
-use crate::state::{connection_status, set_usb_state};
+use crate::state::{current_usb_state, set_usb_state};
 
 pub(crate) static USB_REMOTE_WAKEUP: Signal<RawMutex, ()> = Signal::new();
 
@@ -60,7 +60,7 @@ impl<'a, 'd, D: Driver<'d>> UsbKeyboardWriter<'a, 'd, D> {
             // EndpointError::Disabled never fires on non-OTG STM32/GD32
             // peripherals during suspend, so signal wakeup proactively when a
             // USB report is pending and the bus is suspended.
-            if connection_status().usb == UsbState::Suspended {
+            if current_usb_state() == UsbState::Suspended {
                 USB_REMOTE_WAKEUP.signal(());
             }