feat: parse devices and services

Cargo.toml

···
 [dependencies]
 anyhow = "1.0.68"
 async-stream = "0.3.3"
+colored_json = "3.0.1"
 elementtree = "1.2.3"
 futures-util = "0.3.25"
 http = "0.2.8"
+serde = "1.0.152"
+serde_json = "1.0.91"
 socket2 = "0.4.7"
 surf = { version = "2.3.2", features = ["h1-client-rustls"], default-features = false}
 tokio = { version = "1.24.2", features = ["tokio-macros", "macros", "rt", "rt-multi-thread"] }

src/device_client.rs

···
+use std::time::Duration;
+
+use surf::{Client, Config, Error, Url};
+
+pub struct DeviceClient {
+    http_client: Client,
+}
+
+impl DeviceClient {
+    pub fn new() -> Self {
+        Self {
+            http_client: Config::new()
+                .set_timeout(Some(Duration::from_secs(5)))
+                .try_into()
+                .unwrap(),
+        }
+    }
+
+    pub async fn call_action(&self, service_id: &str, action_name: &str) -> Result<(), Error> {
+        let service_id = resolve_service(service_id);
+        self.get_service_description(&service_id).await;
+        let service_url = Url::parse("http://").unwrap();
+        self.http_client.post(service_url).send().await?;
+        Ok(())
+    }
+
+    async fn get_service_description(&self, service_id: &str) {
+        todo!()
+    }
+}
+
+fn resolve_service(service_id: &str) -> String {
+    match service_id.contains(":") {
+        true => service_id.to_string(),
+        false => format!("urn:upnp-org:serviceId:{}", service_id),
+    }
+}
+
+fn parse_service_description(xml: &str) {
+    todo!()
+}

src/discovery.rs

···
 use anyhow::Error;
 use async_stream::stream;
+use elementtree::Element;
 use futures_util::Stream;
 use socket2::{Domain, Protocol, Socket, Type};
 use std::collections::HashMap;
···
 use std::str;
 use std::thread::sleep;
 use std::time::Duration;
+use surf::http::Method;
+use surf::{Client, Config};
+
+use crate::types::{Device, Service};
 
 const DISCOVERY_REQUEST: &str = "M-SEARCH * HTTP/1.1\r\n\
                                  HOST: 239.255.255.250:1900\r\n\
···
                                  ST: ssdp:all\r\n\
                                  \r\n";
 
-pub fn discover_pnp_locations() -> impl Stream<Item = String> {
+pub fn discover_pnp_locations() -> impl Stream<Item = Device> {
     // Create a UDP socket
     let socket = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP)).unwrap();
 
···
           // Receive the discovery response
           let mut buf = [MaybeUninit::uninit(); 2048];
           let (size, _) = socket.recv_from(&mut buf).unwrap();
-          // Convert the response to a string and parse it as a HTTP response
+          // Convert the response to a string
           let response =
               str::from_utf8(unsafe { std::slice::from_raw_parts(buf.as_ptr() as *const u8, size) })
                   .unwrap();
           let headers = parse_raw_http_response(response).unwrap();
           let location = *headers.get("location").unwrap();
-          yield location.to_string();
+          yield parse_location(location).await.unwrap();
           sleep(Duration::from_millis(500));
       }
     }
···
         None => Err(Error::msg("Invalid HTTP response")),
     }
 }
+
+async fn parse_location(location: &str) -> Result<Device, Error> {
+    let client: Client = Config::new()
+        .set_timeout(Some(Duration::from_secs(5)))
+        .try_into()
+        .unwrap();
+    let req = surf::Request::new(Method::Get, location.parse().unwrap());
+    let xml_root = client.recv_string(req).await.unwrap();
+
+    let mut device: Device = Device::default();
+
+    device.location = location.to_string();
+
+    device.device_type = parse_attribute(
+        &xml_root,
+        "{urn:schemas-upnp-org:device-1-0}device/{urn:schemas-upnp-org:device-1-0}deviceType",
+    )?;
+
+    device.device_type = parse_attribute(
+        &xml_root,
+        "{urn:schemas-upnp-org:device-1-0}device/{urn:schemas-upnp-org:device-1-0}deviceType",
+    )?;
+    device.friendly_name = parse_attribute(
+        &xml_root,
+        "{urn:schemas-upnp-org:device-1-0}device/{urn:schemas-upnp-org:device-1-0}friendlyName",
+    )?;
+    device.manufacturer = parse_attribute(
+        &xml_root,
+        "{urn:schemas-upnp-org:device-1-0}device/{urn:schemas-upnp-org:device-1-0}manufacturer",
+    )?;
+    device.manufacturer_url = match parse_attribute(
+        &xml_root,
+        "{urn:schemas-upnp-org:device-1-0}device/{urn:schemas-upnp-org:device-1-0}manufacturerURL",
+    )? {
+        url if url.is_empty() => None,
+        url => Some(url),
+    };
+    device.model_description = match parse_attribute(
+        &xml_root,
+        "{urn:schemas-upnp-org:device-1-0}device/{urn:schemas-upnp-org:device-1-0}modelDescription",
+    )? {
+        description if description.is_empty() => None,
+        description => Some(description),
+    };
+    device.model_name = parse_attribute(
+        &xml_root,
+        "{urn:schemas-upnp-org:device-1-0}device/{urn:schemas-upnp-org:device-1-0}modelName",
+    )?;
+    device.model_number = match parse_attribute(
+        &xml_root,
+        "{urn:schemas-upnp-org:device-1-0}device/{urn:schemas-upnp-org:device-1-0}modelNumber",
+    )? {
+        number if number.is_empty() => None,
+        number => Some(number),
+    };
+
+    device.services = parse_services(&xml_root);
+
+    Ok(device)
+}
+
+fn parse_attribute(xml_root: &str, xml_name: &str) -> Result<String, Error> {
+    let root = Element::from_reader(xml_root.as_bytes())?;
+    let mut xml_name = xml_name.split('/');
+    match root.find(xml_name.next().unwrap()) {
+        Some(element) => {
+            let element = element.find(xml_name.next().unwrap());
+            match element {
+                Some(element) => {
+                    return Ok(element.text().to_string());
+                }
+                None => {
+                    return Ok("".to_string());
+                }
+            }
+        }
+        None => Ok("".to_string()),
+    }
+}
+
+fn parse_services(xml_root: &str) -> Vec<Service> {
+    let root = Element::from_reader(xml_root.as_bytes()).unwrap();
+    let device = root
+        .find("{urn:schemas-upnp-org:device-1-0}device")
+        .unwrap();
+    let service_list = device.find("{urn:schemas-upnp-org:device-1-0}serviceList");
+    let services = service_list.unwrap().children();
+
+    services
+        .into_iter()
+        .map(|item| Service {
+            service_type: item
+                .find("{urn:schemas-upnp-org:device-1-0}serviceType")
+                .unwrap()
+                .text()
+                .to_string(),
+            service_id: item
+                .find("{urn:schemas-upnp-org:device-1-0}serviceId")
+                .unwrap()
+                .text()
+                .to_string(),
+            control_url: item
+                .find("{urn:schemas-upnp-org:device-1-0}controlURL")
+                .unwrap()
+                .text()
+                .to_string(),
+            event_sub_url: item
+                .find("{urn:schemas-upnp-org:device-1-0}eventSubURL")
+                .unwrap()
+                .text()
+                .to_string(),
+            scpd_url: item
+                .find("{urn:schemas-upnp-org:device-1-0}SCPDURL")
+                .unwrap()
+                .text()
+                .to_string(),
+        })
+        .collect()
+}

src/lib.rs

···
+pub mod device_client;
 pub mod discovery;
+pub mod media_renderer;
+pub mod types;

src/main.rs

···
+use colored_json::prelude::*;
 use futures_util::StreamExt;
 
 use crate::discovery::discover_pnp_locations;
 
 mod discovery;
+mod types;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let locations = discover_pnp_locations();
-    tokio::pin!(locations);
+    let devices = discover_pnp_locations();
+    tokio::pin!(devices);
 
-    while let Some(location) = locations.next().await {
-        println!("discovered location: {}", location);
+    while let Some(device) = devices.next().await {
+        let json = serde_json::to_string_pretty(&device)?;
+        println!("{}", json.to_colored_json_auto()?);
     }
 
     Ok(())

src/media_renderer.rs

···
+use crate::device_client::DeviceClient;
+
+pub struct MediaRendererClient {
+    device_client: DeviceClient,
+}
+
+impl MediaRendererClient {
+    pub fn new() -> Self {
+        Self {
+            device_client: DeviceClient::new(),
+        }
+    }
+    pub fn load(&self, url: &str) {
+        todo!()
+    }
+
+    pub fn play(&self) {
+        todo!()
+    }
+
+    pub fn pause(&self) {
+        todo!()
+    }
+
+    pub fn seek(&self) {
+        todo!()
+    }
+
+    pub fn stop(&self) {
+        todo!()
+    }
+
+    pub fn get_volume(&self) {
+        todo!()
+    }
+
+    pub fn set_volume(&self) {
+        todo!()
+    }
+
+    pub fn get_supported_protocols(&self) {
+        todo!()
+    }
+
+    pub fn get_position(&self) {
+        todo!()
+    }
+
+    pub fn get_duration(&self) {
+        todo!()
+    }
+}

src/types.rs

···
+use serde::{Deserialize, Serialize};
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Device {
+    pub location: String,
+    pub device_type: String,
+    pub friendly_name: String,
+    pub manufacturer: String,
+    pub manufacturer_url: Option<String>,
+    pub model_description: Option<String>,
+    pub model_name: String,
+    pub model_number: Option<String>,
+    pub services: Vec<Service>,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Service {
+    pub service_type: String,
+    pub service_id: String,
+    pub control_url: String,
+    pub event_sub_url: String,
+    pub scpd_url: String,
+}