Merge branch 'dev'

Cargo.lock

@@ -55,7 +55,7 @@ dependencies = [
 
 [[package]]
 name = "mixrs"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "anyhow",
  "libpulse-binding",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mixrs"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 
 [dependencies]

src/mixer.rs

@@ -243,39 +243,38 @@ impl Mixer {
                             }
                         }
                     }
-                    PulseInstruction::RemoveSinkInput(sink_index) => {
+                    PulseInstruction::RemoveSinkInput(sink_index) => 'remove_sink: {
                         let selected_index_lock = self.selected_index.lock().unwrap();
 
-                        match *selected_index_lock {
+                        let Some(selected_index) = *selected_index_lock else {
-                            Some(current_index) => {
+                            break 'remove_sink;
+                        };
+
                         drop(selected_index_lock);
 
-                                if let Some(removed_sink_input_index) =
+                        let Some(removed_sink_input_index) =
                             self.sink_inputs.keys().position(|k| *k == sink_index)
-                                {
+                        else {
-                                    let current_key =
+                            break 'remove_sink;
-                                        *self.sink_inputs.keys().nth(current_index).unwrap();
+                        };
+
+                        let current_key = *self.sink_inputs.keys().nth(selected_index).unwrap();
 
                         if self.sink_inputs.remove(&sink_index).is_some() {
                             if sink_index == current_key
-                                            || removed_sink_input_index > current_index
+                                || removed_sink_input_index <= selected_index
                             {
                                 self.select_previous();
                             }
                         }
                     }
-                            }
+                    PulseInstruction::UpdateSinkInput(sink_index) => 'update_sink: {
-
+                        let Some(sink_input_mixer_data) = self.sink_inputs.get_mut(&sink_index)
-                            None => (),
+                        else {
-                        }
+                            break 'update_sink;
-                    }
+                        };
-                    PulseInstruction::UpdateSinkInput(sink_index) => {
-                        match self.sink_inputs.get_mut(&sink_index) {
-                            Some(sink_input_mixer_data) => {
-                                let new_sink_input: Arc<Mutex<Option<SinkInputMixerData>>> =
-                                    Arc::new(Mutex::new(None));
-                                let callback_new_sink_input = new_sink_input.clone();
 
+                        let (new_sink_tx, new_sink_rx) = channel::<Option<SinkInputMixerData>>();
                         let operation = self
                             .context
                             .borrow_mut()
@@ -283,30 +282,26 @@ impl Mixer {
                             .borrow_mut()
                             .get_sink_input_info(sink_index, move |r| {
                                 let ListResult::Item(sink_input) = r else {
+                                    let _ = new_sink_tx.send(None);
                                     return;
                                 };
 
-                                        *callback_new_sink_input.lock().unwrap() =
+                                let _ = new_sink_tx.send(Some(SinkInputMixerData {
-                                            Some(SinkInputMixerData {
                                     name: get_sink_input_name(&sink_input).unwrap(),
                                     volume: sink_input.volume.avg().0,
                                     channels: sink_input.volume.len(),
                                     muted: sink_input.mute,
-                                            });
+                                }));
                             });
 
                         while operation.get_state() == pulse::operation::State::Running {
                             iterate_mainloop(&mut self.mainloop);
                         }
 
-                                let mut sink_input_lock = new_sink_input.lock().unwrap();
+                        if let Some(new_sink_input) = new_sink_rx.recv().ok().flatten() {
-                                if let Some(new_sink_input) = sink_input_lock.take() {
                             *sink_input_mixer_data = new_sink_input;
                         }
                     }
-                            None => (),
-                        }
-                    }
                 }
             }