wip: update libcosmic (#93)

* wip: update libcosmic

* fix: damge issue resolved by updating iced

* fix: high cpu usage by time applet and app-list

* refactor subscriptions to produce fewer events

* refactor network applet to use less cpu

* fix: text size

* refactor: i18n for audio applet

* refactor: power applet i18n setup

* fix (battery): always send profile update

* fix (battery): set toggler width to layout correctly

* fix (app-list): backoff for restarts of toplevel subscription

* fix (network): alignment

* feat: ask for comfirmation before applying power applet actions

* wip: integrate cosmic-config

* update zbus

* feat: update to use latest libcosmic

* update iced

* udpate deps

* update deps

* refactor: move applet helpers to this repo, outside of libcosmic.

this should help alleviate some dependency hell

* chore update deps

* update deps

* cleanup

cosmic-applet-network/src/network_manager/active_conns.rs

@@ -0,0 +1,56 @@
+use super::{NetworkManagerEvent, NetworkManagerState};
+use cosmic::iced::{self, subscription};
+use cosmic_dbus_networkmanager::nm::NetworkManager;
+use futures::StreamExt;
+use log::error;
+use std::fmt::Debug;
+use std::hash::Hash;
+use zbus::Connection;
+
+pub fn active_conns_subscription<I: 'static + Hash + Copy + Send + Sync + Debug>(
+    id: I,
+    conn: Connection,
+) -> iced::Subscription<(I, NetworkManagerEvent)> {
+    subscription::unfold(id, State::Continue(conn), move |mut state| async move {
+        loop {
+            let (update, new_state) = start_listening(id, state).await;
+            state = new_state;
+            if let Some(update) = update {
+                return (update, state);
+            }
+        }
+    })
+}
+
+#[derive(Debug, Clone)]
+pub enum State {
+    Continue(Connection),
+    Error,
+}
+
+async fn start_listening<I: Copy + Debug>(
+    id: I,
+    state: State,
+) -> (Option<(I, NetworkManagerEvent)>, State) {
+    let conn = match state {
+        State::Continue(conn) => conn,
+        State::Error => iced::futures::future::pending().await,
+    };
+    let network_manager = match NetworkManager::new(&conn).await {
+        Ok(n) => n,
+        Err(e) => {
+            error!("Failed to connect to NetworkManager: {}", e);
+            return (None, State::Error);
+        }
+    };
+
+    let mut active_conns_changed = network_manager.receive_active_connections_changed().await;
+    active_conns_changed.next().await;
+
+    let new_state = NetworkManagerState::new(&conn).await.unwrap_or_default();
+
+    (
+        Some((id, NetworkManagerEvent::ActiveConns(new_state))),
+        State::Continue(conn),
+    )
+}