oxvif 0.7.2

Async Rust client library for the ONVIF IP camera protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Typed response structs for the ONVIF Events service.

use std::collections::HashMap;

use crate::error::OnvifError;
use crate::soap::{SoapError, XmlNode};

// ── PullPointSubscription ─────────────────────────────────────────────────────

/// A pull-point event subscription returned by `CreatePullPointSubscription`.
///
/// Use `reference_url` as the endpoint for `pull_messages`,
/// `renew_subscription`, and `unsubscribe`.
#[derive(Debug, Clone)]
pub struct PullPointSubscription {
    /// Subscription manager endpoint URL.
    pub reference_url: String,
    /// ISO-8601 timestamp when the subscription expires.
    pub termination_time: String,
}

impl PullPointSubscription {
    pub(crate) fn from_xml(resp: &XmlNode) -> Result<Self, OnvifError> {
        let reference_url = resp
            .path(&["SubscriptionReference", "Address"])
            .map(|n| n.text().to_string())
            .ok_or_else(|| SoapError::missing("SubscriptionReference/Address"))?;
        let termination_time = resp
            .child("TerminationTime")
            .map(|n| n.text().to_string())
            .unwrap_or_default();
        Ok(Self {
            reference_url,
            termination_time,
        })
    }
}

// ── NotificationMessage ───────────────────────────────────────────────────────

/// A single ONVIF event notification received via `PullMessages`.
#[derive(Debug, Clone)]
pub struct NotificationMessage {
    /// Topic path (e.g. `tns1:VideoSource/MotionAlarm`).
    pub topic: String,
    /// UTC timestamp from the `Message/@UtcTime` attribute.
    pub utc_time: String,
    /// Source `SimpleItem` pairs (e.g. `VideoSourceToken = "VideoSource_1"`).
    pub source: HashMap<String, String>,
    /// Data `SimpleItem` pairs (e.g. `IsMotion = "true"`).
    pub data: HashMap<String, String>,
}

impl NotificationMessage {
    pub(crate) fn vec_from_xml(resp: &XmlNode) -> Vec<Self> {
        resp.children_named("NotificationMessage")
            .map(Self::from_node)
            .collect()
    }

    fn from_node(node: &XmlNode) -> Self {
        let topic = node
            .child("Topic")
            .map(|n| n.text().trim().to_string())
            .unwrap_or_default();

        // The inner Message element may be wrapped: .../Message/Message[@UtcTime]
        let msg = node
            .path(&["Message", "Message"])
            .or_else(|| node.child("Message"));

        let utc_time = msg
            .and_then(|n| n.attr("UtcTime").map(str::to_string))
            .unwrap_or_default();

        let source = msg
            .and_then(|n| n.child("Source"))
            .map(parse_simple_items)
            .unwrap_or_default();

        let data = msg
            .and_then(|n| n.child("Data"))
            .map(parse_simple_items)
            .unwrap_or_default();

        Self {
            topic,
            utc_time,
            source,
            data,
        }
    }
}

fn parse_simple_items(node: &XmlNode) -> HashMap<String, String> {
    node.children_named("SimpleItem")
        .filter_map(|item| {
            let name = item.attr("Name")?.to_string();
            let value = item.attr("Value").unwrap_or("").to_string();
            Some((name, value))
        })
        .collect()
}

// ── EventProperties ───────────────────────────────────────────────────────────

/// Available event topics advertised by the device.
#[derive(Debug, Clone, Default)]
pub struct EventProperties {
    /// Flattened list of all topic paths (e.g. `VideoSource/MotionAlarm`).
    pub topics: Vec<String>,
}

impl EventProperties {
    pub(crate) fn from_xml(resp: &XmlNode) -> Result<Self, OnvifError> {
        let topic_set = resp
            .child("TopicSet")
            .ok_or_else(|| SoapError::missing("TopicSet"))?;
        let mut topics = Vec::new();
        flatten_topics(topic_set, String::new(), &mut topics);
        Ok(Self { topics })
    }
}

/// Recursively flatten the TopicSet tree into slash-separated paths.
///
/// Leaf nodes are nodes whose children are all `MessageDescription` elements
/// (or that have no children at all). Intermediate nodes become path segments.
fn flatten_topics(node: &XmlNode, prefix: String, out: &mut Vec<String>) {
    for child in &node.children {
        if child.local_name == "MessageDescription" {
            continue;
        }
        let path = if prefix.is_empty() {
            child.local_name.clone()
        } else {
            format!("{prefix}/{}", child.local_name)
        };
        let has_non_desc = child
            .children
            .iter()
            .any(|n| n.local_name != "MessageDescription");
        if has_non_desc {
            flatten_topics(child, path, out);
        } else {
            out.push(path);
        }
    }
}