From 1e52c28e97aa8e39c001f9e4c6a65ff81c3ea474 Mon Sep 17 00:00:00 2001
From: Jacob Casper <dev@jacobcasper.com>
Date: Mon, 19 Oct 2020 14:16:20 -0500
Subject: [PATCH] Store matched encountered property values in map

This is going to be used to create a value for xsetroot -name
eventually, so that the most recent value encountered from multiple
signals is known.
---
 src/main.rs | 29 ++++++++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 9380027..fd92244 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,9 +1,21 @@
 use dbus::blocking::stdintf::org_freedesktop_dbus::PropertiesPropertiesChanged;
 use dbus::blocking::Connection;
 use dbus::message::Message;
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
+fn update_map(arc_map: Arc<Mutex<HashMap<String, String>>>, key: String, val: String) {
+    let clone_arc = arc_map.clone();
+    let mut map = clone_arc.lock().unwrap();
+    map.insert(key, val.clone());
+    for (k, v) in &*map {
+        println! {"{}: {}", k.clone(), v.clone()};
+    }
+}
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let arc_locked_xset_map = Arc::new(Mutex::new(HashMap::new()));
     let conn = Connection::new_session()?;
 
     let proxy = conn.with_proxy(
@@ -13,7 +25,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     );
 
     let _ = proxy.match_signal(
-        |pc: PropertiesPropertiesChanged, _: &Connection, _: &Message| {
+        move |pc: PropertiesPropertiesChanged, _: &Connection, _: &Message| {
             pc.changed_properties["Metadata"]
                 .0
                 .as_iter()
@@ -23,16 +35,27 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                         let key_str = key.as_str()?;
                         let value = iter.next();
 
+                        let arc_locked_xset_map = Arc::clone(&arc_locked_xset_map);
+
                         match key_str {
                             "xesam:artist" => {
                                 // Variant holding a variant that should just be a Vec<&str> I
                                 // believe. This is _the recommended_ way to do this by the author.
                                 let inner_value = value?.as_iter()?.next()?.as_iter()?.next()?;
                                 let artist = String::from(inner_value.as_str()?);
-                                println!("artist: {}", artist);
+                                update_map(
+                                    arc_locked_xset_map,
+                                    String::from("artist"),
+                                    String::from(artist),
+                                );
                             }
                             "xesam:title" => {
-                                println!("title: {}", value?.as_iter()?.next()?.as_str()?);
+                                let title = value?.as_iter()?.next()?.as_str()?;
+                                update_map(
+                                    arc_locked_xset_map,
+                                    String::from("title"),
+                                    String::from(title),
+                                );
                             }
                             _ => (),
                         }
-- 
2.20.1