bairelay 1.1.1

RTSP Relay for Reolink Baichuan cameras
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

//! Per-camera cache of the most-recent MQTT status values.
//!
//! Each camera task that publishes a status topic (battery, motion,
//! floodlight, floodlight_tasks, pir) writes the just-published value
//! into this cache. On a broker reconnect, `handle_connack` walks
//! every camera's cache and re-emits any set value via the standard
//! `publish_*` retained publishers.
//!
//! Why: MQTT brokers without persistence (or whose retained store is
//! reset alongside HA) lose retained messages on restart. Bairelay's
//! own publishes are then the only source of state, but several
//! topics are event-driven (motion, floodlight) or polled at long
//! intervals (battery: 600 s default), so HA can show "unknown" for
//! up to 10 min after such a reset. Re-emitting the cache on every
//! broker reconnect closes the gap.
//!
//! What's NOT cached:
//!
//! - Connection status (`status`) — already published on every
//!   connect/disconnect transition.
//! - Discovery payloads — re-emitted by `mqtt_loop::handle_connack`.
//! - Preview JPEG — refreshed by `preview_poller` every 5 s default.
//! - PTZ preset (`status/ptz/preset`) — bairelay genuinely doesn't
//!   know which preset the camera selected pre-restart, so the
//!   discovery publisher intentionally clears it on every reconnect.

use crate::stream_source::RwLockPoisonRecover as _;
use std::sync::RwLock;

#[derive(Debug, Default)]
pub struct StatusCache {
	battery_level: RwLock<Option<u8>>,
	motion: RwLock<Option<bool>>,
	floodlight: RwLock<Option<bool>>,
	floodlight_tasks: RwLock<Option<bool>>,
	pir: RwLock<Option<bool>>,
}

impl StatusCache {
	pub fn set_battery_level(&self, level: u8) {
		*self.battery_level.write_recover() = Some(level);
	}
	pub fn battery_level(&self) -> Option<u8> {
		*self.battery_level.read_recover()
	}

	pub fn set_motion(&self, detected: bool) {
		*self.motion.write_recover() = Some(detected);
	}
	pub fn motion(&self) -> Option<bool> {
		*self.motion.read_recover()
	}

	pub fn set_floodlight(&self, on: bool) {
		*self.floodlight.write_recover() = Some(on);
	}
	pub fn floodlight(&self) -> Option<bool> {
		*self.floodlight.read_recover()
	}

	pub fn set_floodlight_tasks(&self, enabled: bool) {
		*self.floodlight_tasks.write_recover() = Some(enabled);
	}
	pub fn floodlight_tasks(&self) -> Option<bool> {
		*self.floodlight_tasks.read_recover()
	}

	pub fn set_pir(&self, enabled: bool) {
		*self.pir.write_recover() = Some(enabled);
	}
	pub fn pir(&self) -> Option<bool> {
		*self.pir.read_recover()
	}
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn defaults_to_none() {
		let c = StatusCache::default();
		assert_eq!(c.battery_level(), None);
		assert_eq!(c.motion(), None);
		assert_eq!(c.floodlight(), None);
		assert_eq!(c.floodlight_tasks(), None);
		assert_eq!(c.pir(), None);
	}

	#[test]
	fn round_trips_each_field() {
		let c = StatusCache::default();
		c.set_battery_level(72);
		c.set_motion(true);
		c.set_floodlight(false);
		c.set_floodlight_tasks(true);
		c.set_pir(false);
		assert_eq!(c.battery_level(), Some(72));
		assert_eq!(c.motion(), Some(true));
		assert_eq!(c.floodlight(), Some(false));
		assert_eq!(c.floodlight_tasks(), Some(true));
		assert_eq!(c.pir(), Some(false));
	}

	#[test]
	fn last_write_wins() {
		let c = StatusCache::default();
		c.set_battery_level(50);
		c.set_battery_level(48);
		assert_eq!(c.battery_level(), Some(48));
	}
}