Few optimization and heap allocation elimination (#97)

* optimize controller refresh by removing unplugged adapters in a single pass

* refactor Device struct to use static string for icon and update get_icon return type

* refactor notification system to use StringRef for optimized message handling and add StringRef module

* refactor padding functions to use preallocated buffer and Cow for optimized string handling in requests

Author: fereidani

src/app.rs

@@ -737,30 +737,27 @@ impl App {
     pub async fn refresh(&mut self) -> AppResult<()> {
         let refreshed_controllers = Controller::get_all(self.session.clone()).await?;
 
-        let names = {
-            let mut names: Vec<String> = Vec::new();
+        // Remove unplugged adapters in a single pass
+        let mut adapter_removed = false;
+        self.controllers.retain(|controller| {
+            let should_retain = refreshed_controllers
+                .iter()
+                .any(|c| c.name == controller.name);
 
-            for controller in self.controllers.iter() {
-                if !refreshed_controllers
-                    .iter()
-                    .any(|c| c.name == controller.name)
-                {
-                    names.push(controller.name.clone());
-                }
+            if !should_retain {
+                adapter_removed = true;
             }
 
-            names
-        };
-
-        // Remove unplugged adapters
-        for name in names {
-            self.controllers.retain(|c| c.name != name);
+            should_retain
+        });
 
+        // Update selection after removal
+        if adapter_removed {
             if !self.controllers.is_empty() {
                 let i = match self.controller_state.selected() {
                     Some(i) => {
                         if i > 0 {
-                            i - 1
+                            (i - 1).min(self.controllers.len() - 1)
                         } else {
                             0
                         }

src/bluetooth.rs

@@ -23,7 +23,7 @@ pub struct Controller {
 pub struct Device {
     device: BTDevice,
     pub addr: Address,
-    pub icon: String,
+    pub icon: &'static str,
     pub alias: String,
     pub is_paired: bool,
     pub is_trusted: bool,
@@ -38,19 +38,19 @@ impl Device {
     }
 
     // https://specifications.freedesktop.org/icon-naming/latest/
-    pub fn get_icon(name: &str) -> String {
+    pub fn get_icon(name: &str) -> &'static str {
         match name {
-            "audio-card" => String::from("󰓃 "),
-            "audio-input-microphone" => String::from(" "),
-            "audio-headphones" | "audio-headset" => String::from("󰋋 "),
-            "battery" => String::from("󰂀 "),
-            "camera-photo" => String::from("󰻛 "),
-            "computer" => String::from(" "),
-            "input-keyboard" => String::from("󰌌 "),
-            "input-mouse" => String::from("󰍽 "),
-            "input-gaming" => String::from("󰊴 "),
-            "phone" => String::from("󰏲 "),
-            _ => String::from("󰾰 "),
+            "audio-card" => "󰓃 ",
+            "audio-input-microphone" => " ",
+            "audio-headphones" | "audio-headset" => "󰋋 ",
+            "battery" => "󰂀 ",
+            "camera-photo" => "󰻛 ",
+            "computer" => " ",
+            "input-keyboard" => "󰌌 ",
+            "input-mouse" => "󰍽 ",
+            "input-gaming" => "󰊴 ",
+            "phone" => "󰏲 ",
+            _ => "󰾰 ",
         }
     }
 }

src/handler.rs

@@ -10,5 +10,6 @@ pub mod notification;
 pub mod requests;
 pub mod rfkill;
 pub mod spinner;
+pub mod string_ref;
 pub mod tui;
 pub mod ui;

src/lib.rs

@@ -7,11 +7,11 @@ use ratatui::{
 };
 use tokio::sync::mpsc::UnboundedSender;
 
-use crate::{app::AppResult, event::Event};
+use crate::{app::AppResult, event::Event, string_ref::StringRef};
 
 #[derive(Debug, Clone)]
 pub struct Notification {
-    pub message: String,
+    pub message: StringRef,
     pub level: NotificationLevel,
     pub ttl: u16,
 }
@@ -57,7 +57,7 @@ impl Notification {
         frame.render_widget(block, area);
     }
     pub fn send(
-        message: String,
+        message: StringRef,
         level: NotificationLevel,
         sender: UnboundedSender<Event>,
     ) -> AppResult<()> {

src/notification.rs

@@ -1,3 +1,5 @@
+use std::{borrow::Cow, fmt::Write};
+
 use crate::requests::{
     confirmation::Confirmation, display_passkey::DisplayPasskey, display_pin_code::DisplayPinCode,
     enter_passkey::EnterPasskey, enter_pin_code::EnterPinCode,
@@ -36,11 +38,24 @@ impl Requests {
     }
 }
 
-fn pad_string(input: &str, length: usize) -> String {
+fn pad_str<'a>(input: &'a str, length: usize) -> Cow<'a, str> {
+    let current_length = input.chars().count();
+    if current_length >= length {
+        Cow::Borrowed(input)
+    } else {
+        let mut s = String::with_capacity(length);
+        write!(&mut s, "{:<width$}", input, width = length).unwrap();
+        Cow::Owned(s)
+    }
+}
+
+fn pad_string(input: String, length: usize) -> String {
     let current_length = input.chars().count();
     if current_length >= length {
-        input.to_string()
+        input
     } else {
-        format!("{:<width$}", input, width = length)
+        let mut s = String::with_capacity(length);
+        write!(&mut s, "{:<width$}", input, width = length).unwrap();
+        s
     }
 }

src/requests.rs

@@ -11,7 +11,12 @@ use ratatui::{
 use bluer::Address;
 use tui_input::{Input, backend::crossterm::EventHandler};
 
-use crate::{agent::AuthAgent, app::AppResult, event::Event, requests::pad_string};
+use crate::{
+    agent::AuthAgent,
+    app::AppResult,
+    event::Event,
+    requests::{pad_str, pad_string},
+};
 
 #[derive(Debug, Clone, PartialEq, Default)]
 pub enum FocusedSection {
@@ -177,15 +182,12 @@ impl EnterPasskey {
                     }
                 },
                 Span::from("  "),
-                Span::from(pad_string(
-                    format!(" {}", self.passkey.field.value()).as_str(),
-                    60,
-                ))
-                .bg(Color::DarkGray),
+                Span::from(pad_string(format!(" {}", self.passkey.field.value()), 60))
+                    .bg(Color::DarkGray),
             ]),
-            Line::from(vec![Span::from(pad_string(" ", 9)), {
+            Line::from(vec![Span::from(pad_str(" ", 9)), {
                 if let Some(error) = &self.passkey.error {
-                    Span::from(pad_string(error, 60))
+                    Span::from(pad_str(error, 60))
                 } else {
                     Span::from("")
                 }

src/requests/enter_passkey.rs

@@ -11,7 +11,12 @@ use ratatui::{
 use bluer::Address;
 use tui_input::{Input, backend::crossterm::EventHandler};
 
-use crate::{agent::AuthAgent, app::AppResult, event::Event, requests::pad_string};
+use crate::{
+    agent::AuthAgent,
+    app::AppResult,
+    event::Event,
+    requests::{pad_str, pad_string},
+};
 
 #[derive(Debug, Clone, PartialEq, Default)]
 pub enum FocusedSection {
@@ -171,15 +176,12 @@ impl EnterPinCode {
                     }
                 },
                 Span::from("  "),
-                Span::from(pad_string(
-                    format!(" {}", self.pin_code.field.value()).as_str(),
-                    60,
-                ))
-                .bg(Color::DarkGray),
+                Span::from(pad_string(format!(" {}", self.pin_code.field.value()), 60))
+                    .bg(Color::DarkGray),
             ]),
-            Line::from(vec![Span::from(pad_string(" ", 10)), {
+            Line::from(vec![Span::from(pad_str(" ", 10)), {
                 if let Some(error) = &self.pin_code.error {
-                    Span::from(pad_string(error, 60))
+                    Span::from(pad_str(error, 60))
                 } else {
                     Span::from("")
                 }

src/requests/enter_pin_code.rs

@@ -0,0 +1,67 @@
+pub enum StringRef {
+    Owned(String),
+    Static(&'static str),
+}
+
+impl StringRef {
+    pub fn as_str(&self) -> &str {
+        match self {
+            StringRef::Owned(s) => s.as_str(),
+            StringRef::Static(s) => s,
+        }
+    }
+}
+
+impl From<String> for StringRef {
+    fn from(s: String) -> Self {
+        StringRef::Owned(s)
+    }
+}
+
+impl From<&'static str> for StringRef {
+    fn from(s: &'static str) -> Self {
+        StringRef::Static(s)
+    }
+}
+
+impl From<bluer::Error> for StringRef {
+    fn from(err: bluer::Error) -> Self {
+        StringRef::Owned(err.to_string())
+    }
+}
+
+impl From<anyhow::Error> for StringRef {
+    fn from(err: anyhow::Error) -> Self {
+        StringRef::Owned(err.to_string())
+    }
+}
+
+impl AsRef<str> for StringRef {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl std::fmt::Display for StringRef {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl std::fmt::Debug for StringRef {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StringRef::Owned(s) => write!(f, "StringRef::Owned({:?})", s),
+            StringRef::Static(s) => write!(f, "StringRef::Static({:?})", s),
+        }
+    }
+}
+
+impl Clone for StringRef {
+    fn clone(&self) -> Self {
+        match self {
+            StringRef::Owned(s) => StringRef::Owned(s.clone()),
+            StringRef::Static(s) => StringRef::Static(s),
+        }
+    }
+}