wip: bluetooth applet

cosmic-applet-bluetooth/src/app.rs

@@ -0,0 +1,406 @@
+use std::f32::consts::E;
+
+use crate::bluetooth::{BluerDeviceStatus, BluerRequest, BluerState};
+use cosmic::applet::APPLET_BUTTON_THEME;
+use cosmic::iced_style;
+use cosmic::widget::ListColumn;
+use cosmic::{
+    applet::CosmicAppletHelper,
+    iced::{
+        wayland::{
+            popup::{destroy_popup, get_popup},
+            SurfaceIdWrapper,
+        },
+        widget::{column, container, row, scrollable, text, text_input, Column},
+        Alignment, Application, Color, Command, Length, Subscription,
+    },
+    iced_native::{
+        alignment::{Horizontal, Vertical},
+        layout::Limits,
+        renderer::BorderRadius,
+        window,
+    },
+    iced_style::{application, button::StyleSheet, svg},
+    theme::{Button, Svg},
+    widget::{button, divider, icon, toggler},
+    Element, Theme,
+};
+use tokio::sync::mpsc::Sender;
+
+use crate::bluetooth::{bluetooth_subscription, BluerEvent};
+use crate::{config, fl};
+
+pub fn run() -> cosmic::iced::Result {
+    let helper = CosmicAppletHelper::default();
+    CosmicBluetoothApplet::run(helper.window_settings())
+}
+
+#[derive(Debug)]
+enum NewConnectionState {
+    EnterPassword { device: (), password: String },
+    Waiting(()),
+    Failure(()),
+}
+
+// impl Into<()> for NewConnectionState {
+//     fn into(self) -> AccessPoint {
+//         match self {
+//             NewConnectionState::EnterPassword {
+//                 access_point,
+//                 password,
+//             } => access_point,
+//             NewConnectionState::Waiting(access_point) => access_point,
+//             NewConnectionState::Failure(access_point) => access_point,
+//         }
+//     }
+// }
+
+#[derive(Default)]
+struct CosmicBluetoothApplet {
+    icon_name: String,
+    theme: Theme,
+    popup: Option<window::Id>,
+    id_ctr: u32,
+    applet_helper: CosmicAppletHelper,
+    bluer_state: BluerState,
+    bluer_sender: Option<Sender<BluerRequest>>,
+    // UI state
+    show_visible_devices: bool,
+    new_connection: Option<NewConnectionState>,
+}
+
+#[derive(Debug, Clone)]
+enum Message {
+    TogglePopup,
+    ToggleVisibleDevices(bool),
+    Errored(String),
+    Ignore,
+    BluetoothEvent(BluerEvent),
+    Request(BluerRequest),
+}
+
+impl Application for CosmicBluetoothApplet {
+    type Message = Message;
+    type Theme = Theme;
+    type Executor = cosmic::SingleThreadExecutor;
+    type Flags = ();
+
+    fn new(_flags: ()) -> (Self, Command<Message>) {
+        (
+            CosmicBluetoothApplet {
+                icon_name: "bluetooth-symbolic".to_string(),
+                ..Default::default()
+            },
+            Command::none(),
+        )
+    }
+
+    fn title(&self) -> String {
+        config::APP_ID.to_string()
+    }
+
+    fn update(&mut self, message: Message) -> Command<Message> {
+        match message {
+            Message::TogglePopup => {
+                if let Some(p) = self.popup.take() {
+                    return destroy_popup(p);
+                } else {
+                    // TODO request update of state maybe
+                    self.id_ctr += 1;
+                    let new_id = window::Id::new(self.id_ctr);
+                    self.popup.replace(new_id);
+
+                    let mut popup_settings = self.applet_helper.get_popup_settings(
+                        window::Id::new(0),
+                        new_id,
+                        None,
+                        None,
+                        None,
+                    );
+
+                    popup_settings.positioner.size_limits = Limits::NONE
+                        .min_height(1)
+                        .min_width(1)
+                        .max_height(800)
+                        .max_width(400);
+                    return get_popup(popup_settings);
+                }
+            }
+            Message::Errored(_) => todo!(),
+            Message::Ignore => {}
+            // Message::SelectDevice(device) => {
+            // let tx = if let Some(tx) = self.nm_sender.as_ref() {
+            //     tx
+            // } else {
+            //     return Command::none();
+            // };
+
+            // let _ = tx.unbounded_send(NetworkManagerRequest::SelectAccessPoint(
+            //     access_point.ssid.clone(),
+            // ));
+
+            // self.new_connection
+            //     .replace(NewConnectionState::EnterPassword {
+            //         access_point,
+            //         password: String::new(),
+            //     });
+            // }
+            Message::ToggleVisibleDevices(enabled) => {
+                self.new_connection.take();
+                self.show_visible_devices = enabled;
+            }
+            Message::BluetoothEvent(e) => match e {
+                BluerEvent::RequestResponse {
+                    req: _req,
+                    state,
+                    err_msg,
+                } => {
+                    if let Some(err_msg) = err_msg {
+                        eprintln!("bluetooth request error: {}", err_msg);
+                    }
+                    dbg!(&state);
+                    self.bluer_state = state;
+                    // TODO special handling for some requests
+                }
+                BluerEvent::Init { sender, state } => {
+                    self.bluer_sender.replace(sender);
+                    self.bluer_state = state;
+                }
+                BluerEvent::DevicesChanged { state } => {
+                    self.bluer_state = state;
+                }
+                BluerEvent::Finished => {
+                    // TODO exit?
+                    todo!()
+                }
+            },
+            Message::Request(r) => {
+                match &r {
+                    BluerRequest::SetBluetoothEnabled(enabled) => {
+                        self.bluer_state.bluetooth_enabled = *enabled;
+                        if !*enabled {
+                            self.bluer_state = BluerState::default();
+                        }
+                    }
+                    BluerRequest::ConnectDevice(add) => {
+                        self.bluer_state
+                            .devices
+                            .iter_mut()
+                            .find(|d| d.address == *add)
+                            .map(|d| {
+                                d.status = BluerDeviceStatus::Connecting;
+                            });
+                    }
+                    BluerRequest::DisconnectDevice(add) => {
+                        self.bluer_state
+                            .devices
+                            .iter_mut()
+                            .find(|d| d.address == *add)
+                            .map(|d| {
+                                d.status = BluerDeviceStatus::Disconnecting;
+                            });
+                    }
+                    BluerRequest::PairDevice(add) => {
+                        self.bluer_state
+                            .devices
+                            .iter_mut()
+                            .find(|d| d.address == *add)
+                            .map(|d| {
+                                d.status = BluerDeviceStatus::Pairing;
+                            });
+                    }
+                    _ => {} // TODO
+                }
+                if let Some(tx) = self.bluer_sender.as_mut().cloned() {
+                    return Command::perform(
+                        async move {
+                            let _ = tx.send(r).await;
+                        },
+                        |_| Message::Ignore, // Error handling
+                    );
+                }
+            }
+        }
+        Command::none()
+    }
+    fn view(&self, id: SurfaceIdWrapper) -> Element<Message> {
+        let button_style = Button::Custom {
+            active: |t| iced_style::button::Appearance {
+                border_radius: BorderRadius::from(0.0),
+                ..t.active(&Button::Text)
+            },
+            hover: |t| iced_style::button::Appearance {
+                border_radius: BorderRadius::from(0.0),
+                ..t.hovered(&Button::Text)
+            },
+        };
+        match id {
+            SurfaceIdWrapper::LayerSurface(_) => unimplemented!(),
+            SurfaceIdWrapper::Window(_) => self
+                .applet_helper
+                .icon_button(&self.icon_name)
+                .on_press(Message::TogglePopup)
+                .into(),
+            SurfaceIdWrapper::Popup(_) => {
+                let mut known_bluetooth = column![];
+                for dev in &self.bluer_state.devices {
+                    let mut row = row![].align_items(Alignment::Center);
+                    row = row.push(
+                        text(dev.name.clone())
+                            .horizontal_alignment(Horizontal::Left)
+                            .vertical_alignment(Vertical::Center)
+                            .width(Length::Fill),
+                    );
+                    match &dev.status {
+                        BluerDeviceStatus::Connected => {
+                            row = row.push(
+                                text(fl!("connected"))
+                                    .horizontal_alignment(Horizontal::Right)
+                                    .vertical_alignment(Vertical::Center),
+                            );
+                        }
+                        BluerDeviceStatus::Paired => {}
+                        BluerDeviceStatus::Connecting | BluerDeviceStatus::Disconnecting => {
+                            row = row.push(
+                                icon("process-working-symbolic", 24)
+                                    .style(Svg::Custom(|theme| svg::Appearance {
+                                        color: Some(theme.palette().text),
+                                    }))
+                                    .width(Length::Units(24))
+                                    .height(Length::Units(24)),
+                            );
+                        }
+                        BluerDeviceStatus::Disconnected | BluerDeviceStatus::Pairing => continue,
+                    };
+
+                    known_bluetooth = known_bluetooth.push(
+                        button(APPLET_BUTTON_THEME)
+                            .custom(vec![row.into()])
+                            .on_press(match dev.status {
+                                BluerDeviceStatus::Connected => {
+                                    Message::Request(BluerRequest::DisconnectDevice(dev.address))
+                                }
+                                BluerDeviceStatus::Disconnected => {
+                                    Message::Request(BluerRequest::PairDevice(dev.address))
+                                }
+                                BluerDeviceStatus::Paired => {
+                                    Message::Request(BluerRequest::ConnectDevice(dev.address))
+                                }
+                                BluerDeviceStatus::Connecting => {
+                                    Message::Request(BluerRequest::CancelConnect(dev.address))
+                                }
+                                BluerDeviceStatus::Disconnecting => Message::Ignore, // Start connecting?
+                                BluerDeviceStatus::Pairing => Message::Ignore, // Cancel pairing?
+                            })
+                            .width(Length::Fill),
+                    );
+                }
+
+                let mut content = column![
+                    container(
+                        toggler(fl!("bluetooth"), self.bluer_state.bluetooth_enabled, |m| {
+                            Message::Request(BluerRequest::SetBluetoothEnabled(m))
+                        },)
+                        .width(Length::Fill)
+                    )
+                    .padding([0, 12]),
+                    divider::horizontal::light(),
+                    known_bluetooth,
+                ]
+                .align_items(Alignment::Center)
+                .spacing(8)
+                .padding([8, 0]);
+                let dropdown_icon = if self.show_visible_devices {
+                    "go-down-symbolic"
+                } else {
+                    "go-next-symbolic"
+                };
+                let available_connections_btn = button(Button::Secondary)
+                    .custom(
+                        vec![
+                            text(fl!("other-devices"))
+                                .size(14)
+                                .width(Length::Fill)
+                                .height(Length::Units(24))
+                                .vertical_alignment(Vertical::Center)
+                                .into(),
+                            container(
+                                icon(dropdown_icon, 14)
+                                    .style(Svg::Custom(|theme| svg::Appearance {
+                                        color: Some(theme.palette().text),
+                                    }))
+                                    .width(Length::Units(14))
+                                    .height(Length::Units(14)),
+                            )
+                            .align_x(Horizontal::Center)
+                            .align_y(Vertical::Center)
+                            .width(Length::Units(24))
+                            .height(Length::Units(24))
+                            .into(),
+                        ]
+                        .into(),
+                    )
+                    .padding([8, 24])
+                    .style(button_style.clone())
+                    .on_press(Message::ToggleVisibleDevices(!self.show_visible_devices));
+                content = content.push(available_connections_btn);
+                if self.show_visible_devices {
+                    let mut list_column = Vec::with_capacity(self.bluer_state.devices.len());
+
+                    if self.bluer_state.bluetooth_enabled {
+                        let mut visible_devices = column![];
+                        for dev in self.bluer_state.devices.iter().filter(|d| {
+                            matches!(
+                                d.status,
+                                BluerDeviceStatus::Disconnected | BluerDeviceStatus::Pairing
+                            )
+                        }) {
+                            let mut row = row![].width(Length::Fill).align_items(Alignment::Center);
+                            row = row.push(
+                                text(dev.name.clone()).horizontal_alignment(Horizontal::Left),
+                            );
+                            visible_devices = visible_devices.push(
+                                button(APPLET_BUTTON_THEME)
+                                    .custom(vec![row.width(Length::Fill).into()])
+                                    .on_press(Message::Request(BluerRequest::PairDevice(
+                                        dev.address.clone(),
+                                    )))
+                                    .width(Length::Fill),
+                            );
+                        }
+                        list_column.push(visible_devices.into());
+                    }
+                    let num_dev = list_column.len();
+                    if num_dev > 5 {
+                        content = content.push(
+                            scrollable(Column::with_children(list_column))
+                                .height(Length::Units(300)),
+                        );
+                    } else {
+                        content = content.push(Column::with_children(list_column));
+                    }
+                }
+                self.applet_helper.popup_container(content).into()
+            }
+        }
+    }
+
+    fn subscription(&self) -> Subscription<Message> {
+        bluetooth_subscription(0).map(|e| Message::BluetoothEvent(e.1))
+    }
+
+    fn theme(&self) -> Theme {
+        self.theme
+    }
+
+    fn close_requested(&self, _id: SurfaceIdWrapper) -> Self::Message {
+        Message::Ignore
+    }
+
+    fn style(&self) -> <Self::Theme as application::StyleSheet>::Style {
+        <Self::Theme as application::StyleSheet>::Style::Custom(|theme| application::Appearance {
+            background_color: Color::from_rgba(0.0, 0.0, 0.0, 0.0),
+            text_color: theme.cosmic().on_bg_color().into(),
+        })
+    }
+}

cosmic-applet-bluetooth/src/bluetooth.rs

@@ -0,0 +1,440 @@
+use std::{collections::HashMap, fmt::Debug, hash::Hash, sync::Arc, time::Duration};
+
+use bluer::{Adapter, AdapterProperty, Address, DeviceProperty, Session};
+use cosmic::iced::{self, subscription};
+
+use futures::StreamExt;
+use tokio::{
+    spawn,
+    sync::{
+        mpsc::{channel, Receiver, Sender},
+        Mutex,
+    },
+    task::JoinHandle,
+    time::timeout,
+};
+
+pub fn bluetooth_subscription<I: 'static + Hash + Copy + Send + Sync + Debug>(
+    id: I,
+) -> iced::Subscription<(I, BluerEvent)> {
+    subscription::unfold(id, State::Ready, move |state| start_listening(id, state))
+}
+
+#[derive(Debug)]
+pub enum State {
+    Ready,
+    Waiting { session_state: BluerSessionState },
+    Finished,
+}
+
+async fn start_listening<I: Copy + Debug>(id: I, state: State) -> (Option<(I, BluerEvent)>, State) {
+    match state {
+        State::Ready => {
+            let session = match Session::new().await {
+                Ok(s) => s,
+                Err(_) => return (None, State::Finished),
+            };
+            let (tx, rx) = channel(100);
+
+            let session_state = match BluerSessionState::new(session, rx).await {
+                Ok(s) => s,
+                Err(_) => return (None, State::Finished),
+            };
+
+            let state = session_state.bluer_state().await;
+            return (
+                Some((
+                    id,
+                    BluerEvent::Init {
+                        sender: tx,
+                        state: state.clone(),
+                    },
+                )),
+                State::Waiting { session_state },
+            );
+        }
+        State::Waiting { mut session_state } => {
+            let mut session_rx = match session_state.rx.take() {
+                Some(rx) => rx,
+                None => {
+                    // try restarting the stream
+                    session_state.process_changes();
+                    match session_state.rx.take() {
+                        Some(rx) => rx,
+                        None => {
+                            return (None, State::Finished); // fail if we can't restart the stream
+                        }
+                    }
+                }
+            };
+
+            let event = if let Some(event) = session_rx.recv().await {
+                match event {
+                    BluerSessionEvent::ChangesProcessed(state) => {
+                        return (
+                            Some((id, BluerEvent::DevicesChanged { state })),
+                            State::Waiting { session_state },
+                        );
+                    }
+                    BluerSessionEvent::RequestResponse {
+                        req,
+                        state,
+                        err_msg,
+                    } => Some((
+                        id,
+                        BluerEvent::RequestResponse {
+                            req,
+                            state,
+                            err_msg,
+                        },
+                    )),
+                    _ => None,
+                }
+            } else {
+                return (None, State::Finished);
+            };
+
+            session_state.rx = Some(session_rx);
+            (event, State::Waiting { session_state })
+        }
+        State::Finished => iced::futures::future::pending().await,
+    }
+}
+
+#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+pub enum BluerRequest {
+    SetBluetoothEnabled(bool),
+    PairDevice(Address),
+    ConnectDevice(Address),
+    DisconnectDevice(Address),
+    CancelConnect(Address),
+}
+
+#[derive(Debug, Clone)]
+pub enum BluerEvent {
+    RequestResponse {
+        req: BluerRequest,
+        state: BluerState,
+        err_msg: Option<String>,
+    },
+    Init {
+        sender: Sender<BluerRequest>,
+        state: BluerState,
+    },
+    DevicesChanged {
+        state: BluerState,
+    },
+    Finished,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct BluerState {
+    pub devices: Vec<BluerDevice>,
+    pub bluetooth_enabled: bool,
+}
+
+#[derive(Debug, Clone)]
+pub enum BluerDeviceStatus {
+    Connected,
+    Disconnected,
+    Paired,
+    Connecting,
+    Disconnecting,
+    Pairing,
+}
+
+#[derive(Debug, Clone)]
+pub struct BluerDevice {
+    pub name: String,
+    pub address: Address,
+    pub status: BluerDeviceStatus,
+    pub properties: Vec<DeviceProperty>,
+}
+
+pub enum BluerSessionEvent {
+    RequestResponse {
+        req: BluerRequest,
+        state: BluerState,
+        err_msg: Option<String>,
+    },
+    ChangesProcessed(BluerState),
+    ChangeStreamEnded, // TODO can we just restart the stream in a new task?
+}
+
+#[derive(Debug)]
+pub struct BluerSessionState {
+    session: Session,
+    pub adapter: Adapter,
+    pub devices: Arc<Mutex<Vec<BluerDevice>>>,
+    pub rx: Option<Receiver<BluerSessionEvent>>,
+    tx: Option<Sender<BluerSessionEvent>>,
+    active_requests: Arc<Mutex<HashMap<BluerRequest, JoinHandle<anyhow::Result<()>>>>>,
+}
+
+impl BluerSessionState {
+    pub(crate) async fn new(
+        session: Session,
+        request_rx: Receiver<BluerRequest>,
+    ) -> anyhow::Result<Self> {
+        let adapter = session.default_adapter().await?;
+        let devices = build_device_list(&adapter).await;
+
+        let mut self_ = Self {
+            session,
+            adapter: adapter,
+            devices: Arc::new(Mutex::new(devices)),
+            rx: None,
+            tx: None,
+            active_requests: Arc::new(Mutex::new(HashMap::new())),
+        };
+        self_.process_changes();
+        self_.process_requests(request_rx);
+
+        Ok(self_)
+    }
+
+    pub(crate) async fn devices(&self) -> Vec<BluerDevice> {
+        self.devices.lock().await.clone()
+    }
+
+    pub(crate) async fn clear(&mut self) {
+        self.devices.lock().await.clear();
+    }
+
+    pub(crate) fn start_monitoring(&mut self) {
+        self.process_changes();
+    }
+
+    pub(crate) fn process_changes(&mut self) {
+        let (tx, rx) = tokio::sync::mpsc::channel(100);
+        self.tx = Some(tx.clone());
+        let devices_clone = self.devices.clone();
+        let adapter_clone = self.adapter.clone();
+        let _monitor_devices: tokio::task::JoinHandle<Result<(), anyhow::Error>> =
+            spawn(async move {
+                let mut change_stream = adapter_clone.discover_devices_with_changes().await?;
+
+                let mut cur = None;
+                let mut devices_changed = false;
+                let mut milli_timeout = 10;
+                'outer: loop {
+                    while let Ok(event) =
+                        timeout(Duration::from_millis(milli_timeout), change_stream.next()).await
+                    {
+                        let event = match event {
+                            Some(e) => e,
+                            None => break 'outer, // No more events to receive...
+                        };
+                        let mut devices = devices_clone.lock().await;
+                        match event {
+                            bluer::AdapterEvent::DeviceAdded(address) => {
+                                let device = match adapter_clone.device(address) {
+                                    Ok(d) => d,
+                                    Err(_) => continue,
+                                };
+
+                                let mut status = if device.is_connected().await? {
+                                    BluerDeviceStatus::Connected
+                                } else if device.is_paired().await? {
+                                    BluerDeviceStatus::Paired
+                                } else {
+                                    BluerDeviceStatus::Disconnected
+                                };
+
+                                if let Some(pos) =
+                                    devices.iter().position(|device| device.address == address)
+                                {
+                                    cur = Some(pos);
+                                    continue;
+                                };
+                                // only send a DevicesChanged event if we have actually added a device
+                                devices_changed = true;
+
+                                devices.push(BluerDevice {
+                                    name: device
+                                        .name()
+                                        .await
+                                        .unwrap_or_default()
+                                        .unwrap_or_default(),
+                                    address: device.address(),
+                                    status,
+                                    properties: Vec::new(),
+                                });
+                                cur = Some(devices.len() - 1);
+                            }
+                            bluer::AdapterEvent::DeviceRemoved(address) => {
+                                if let Some(pos) =
+                                    devices.iter().position(|device| device.address == address)
+                                {
+                                    devices_changed = true;
+                                    cur = None;
+                                    devices.remove(pos);
+                                };
+                            }
+                            bluer::AdapterEvent::PropertyChanged(prop) => {
+                                let bluer_device = match cur.and_then(|i| devices.get_mut(i)) {
+                                    Some(d) => d,
+                                    None => continue,
+                                };
+                                devices_changed = true;
+                            }
+                        }
+                    }
+                    if devices_changed {
+                        devices_changed = false;
+                        dbg!(&devices_clone);
+                        let _ = tx
+                            .send(BluerSessionEvent::ChangesProcessed(BluerState {
+                                devices: build_device_list(&adapter_clone).await,
+                                bluetooth_enabled: true,
+                            }))
+                            .await;
+                        // reset timeout
+                        milli_timeout = 10;
+                    } else {
+                        // slow down if no changes occur
+                        milli_timeout = (milli_timeout * 2).max(5120);
+                    }
+                }
+                eprintln!("Change stream ended");
+                Ok(())
+            });
+        self.rx.replace(rx);
+    }
+
+    pub(crate) fn process_requests(&self, request_rx: Receiver<BluerRequest>) {
+        let active_requests = self.active_requests.clone();
+        let adapter = self.adapter.clone();
+        let devices = self.devices.clone();
+        let tx = self.tx.clone().unwrap(); // TODO error handling
+        let _handle: JoinHandle<anyhow::Result<()>> = spawn(async move {
+            let mut request_rx = request_rx;
+
+            while let Some(req) = request_rx.recv().await {
+                let req_clone = req.clone();
+                let req_clone_2 = req.clone();
+                let active_requests_clone = active_requests.clone();
+                let devices_clone = devices.clone();
+                let tx_clone = tx.clone();
+                let adapter_clone = adapter.clone();
+                let handle = spawn(async move {
+                    let mut err_msg = None;
+                    match &req_clone {
+                        BluerRequest::SetBluetoothEnabled(enabled) => {
+                            let res = adapter_clone.set_powered(*enabled).await;
+                            if let Err(e) = res {
+                                err_msg = Some(e.to_string());
+                            }
+                            if *enabled {
+                                let res = adapter_clone.set_discoverable(*enabled).await;
+                                if let Err(e) = res {
+                                    err_msg = Some(e.to_string());
+                                }
+                            }
+                        }
+                        BluerRequest::PairDevice(address) => {
+                            let res = adapter_clone.device(address.clone());
+                            if let Err(err) = res {
+                                err_msg = Some(err.to_string());
+                            } else if let Ok(device) = res {
+                                let res = device.pair().await;
+                                if let Err(err) = res {
+                                    err_msg = Some(err.to_string());
+                                }
+                            }
+                        }
+                        BluerRequest::ConnectDevice(address) => {
+                            let res = adapter_clone.device(address.clone());
+                            if let Err(err) = res {
+                                err_msg = Some(err.to_string());
+                            } else if let Ok(device) = res {
+                                let res = device.connect().await;
+                                if let Err(err) = res {
+                                    err_msg = Some(err.to_string());
+                                }
+                            }
+                        }
+                        BluerRequest::DisconnectDevice(address) => {
+                            let res = adapter_clone.device(address.clone());
+                            if let Err(err) = res {
+                                err_msg = Some(err.to_string());
+                            } else if let Ok(device) = res {
+                                let res = device.disconnect().await;
+                                if let Err(err) = res {
+                                    err_msg = Some(err.to_string());
+                                }
+                            }
+                        }
+                        BluerRequest::CancelConnect(_) => {
+                            if let Some(handle) = active_requests_clone.lock().await.get(&req_clone)
+                            {
+                                handle.abort();
+                            } else {
+                                err_msg = Some("No active connection request found".to_string());
+                            }
+                        }
+                    };
+
+                    let state = BluerState {
+                        devices: build_device_list(&adapter_clone).await,
+                        bluetooth_enabled: adapter_clone.is_powered().await.unwrap_or_default(),
+                    };
+
+                    let _ = tx_clone
+                        .send(BluerSessionEvent::RequestResponse {
+                            req: req_clone,
+                            state,
+                            err_msg,
+                        })
+                        .await;
+
+                    let mut active_requests_clone = active_requests_clone.lock().await;
+                    let _ = active_requests_clone.remove(&req_clone_2);
+
+                    Ok(())
+                });
+
+                active_requests.lock().await.insert(req, handle);
+            }
+            Ok(())
+        });
+    }
+
+    pub(crate) async fn bluer_state(&self) -> BluerState {
+        BluerState {
+            devices: build_device_list(&self.adapter).await,
+            // TODO is this a proper way of checking if bluetooth is enabled?
+            bluetooth_enabled: self.adapter.is_powered().await.unwrap_or_default(),
+        }
+    }
+}
+
+async fn build_device_list(adapter: &Adapter) -> Vec<BluerDevice> {
+    let addrs = adapter.device_addresses().await.unwrap_or_default();
+    let mut devices = Vec::with_capacity(addrs.len());
+
+    for address in addrs {
+        let device = match adapter.device(address) {
+            Ok(device) => device,
+            Err(_) => continue,
+        };
+        let name = device.name().await.unwrap_or_default().unwrap_or_default();
+        let is_paired = device.is_paired().await.unwrap_or_default();
+        let is_connected = device.is_connected().await.unwrap_or_default();
+        let properties = device.all_properties().await.unwrap_or_default();
+        let status = if is_connected {
+            BluerDeviceStatus::Connected
+        } else if is_paired {
+            BluerDeviceStatus::Paired
+        } else {
+            BluerDeviceStatus::Disconnected
+        };
+        devices.push(BluerDevice {
+            name,
+            address,
+            status,
+            properties,
+        });
+    }
+    devices
+}

cosmic-applet-bluetooth/src/config.rs

@@ -0,0 +1,3 @@
+pub const APP_ID: &str = "com.system76.CosmicAppletNetwork";
+pub const PROFILE: &str = "";
+pub const VERSION: &str = "0.1.0";

cosmic-applet-bluetooth/src/localize.rs

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MPL-2.0-only
+
+use i18n_embed::{
+    fluent::{fluent_language_loader, FluentLanguageLoader},
+    DefaultLocalizer, LanguageLoader, Localizer,
+};
+use once_cell::sync::Lazy;
+use rust_embed::RustEmbed;
+
+#[derive(RustEmbed)]
+#[folder = "i18n/"]
+struct Localizations;
+
+pub static LANGUAGE_LOADER: Lazy<FluentLanguageLoader> = Lazy::new(|| {
+    let loader: FluentLanguageLoader = fluent_language_loader!();
+
+    loader
+        .load_fallback_language(&Localizations)
+        .expect("Error while loading fallback language");
+
+    loader
+});
+
+#[macro_export]
+macro_rules! fl {
+    ($message_id:literal) => {{
+        i18n_embed_fl::fl!($crate::localize::LANGUAGE_LOADER, $message_id)
+    }};
+
+    ($message_id:literal, $($args:expr),*) => {{
+        i18n_embed_fl::fl!($crate::localize::LANGUAGE_LOADER, $message_id, $($args), *)
+    }};
+}
+
+// Get the `Localizer` to be used for localizing this library.
+pub fn localizer() -> Box<dyn Localizer> {
+    Box::from(DefaultLocalizer::new(&*LANGUAGE_LOADER, &Localizations))
+}
+
+pub fn localize() {
+    let localizer = localizer();
+    let requested_languages = i18n_embed::DesktopLanguageRequester::requested_languages();
+
+    if let Err(error) = localizer.select(&requested_languages) {
+        eprintln!("Error while loading language for App List {}", error);
+    }
+}

cosmic-applet-bluetooth/src/main.rs

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+mod app;
+mod bluetooth;
+mod config;
+mod localize;
+
+use log::info;
+
+use crate::config::{APP_ID, PROFILE, VERSION};
+use crate::localize::localize;
+
+fn main() -> cosmic::iced::Result {
+    // Initialize logger
+    pretty_env_logger::init();
+    info!("Iced Workspaces Applet ({})", APP_ID);
+    info!("Version: {} ({})", VERSION, PROFILE);
+
+    // Prepare i18n
+    localize();
+
+    app::run()
+}