Party mode
This commit is contained in:
@ -1,22 +1,22 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use chrono::{DateTime, Datelike, Local, NaiveTime, Weekday};
|
||||
use common::{ClientMessage, ServerMessage};
|
||||
use lighter_lib::{BulbColor, BulbId};
|
||||
use common::{BulbPrefs, ClientMessage, ScriptId, ServerMessage};
|
||||
use lighter_lib::BulbId;
|
||||
use lighter_manager::manager::{BulbCommand, BulbManager, BulbSelector};
|
||||
use lighter_manager::provider::mqtt::BulbsMqtt;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::time::Duration;
|
||||
use tokio::select;
|
||||
use tokio::sync::{broadcast, mpsc};
|
||||
use tokio::task::{spawn, JoinHandle};
|
||||
use tokio::time::sleep;
|
||||
|
||||
use crate::persistence::PersistenceFile;
|
||||
use crate::{ClientRequest, State};
|
||||
use crate::State;
|
||||
|
||||
use self::scripts::{LightScript, Party, Waker};
|
||||
|
||||
pub mod scripts;
|
||||
|
||||
#[derive(Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
struct LightsState {
|
||||
wake_schedule: HashMap<BulbId, HashMap<Weekday, NaiveTime>>,
|
||||
script_prefs: HashMap<ScriptId, HashMap<BulbId, BulbPrefs>>,
|
||||
}
|
||||
|
||||
pub async fn lights_task(state: &State) {
|
||||
@ -29,36 +29,43 @@ pub async fn lights_task(state: &State) {
|
||||
.await
|
||||
.expect("Failed to open lights config");
|
||||
|
||||
let (cmd, bulb_states) = BulbManager::launch(config.bulbs.clone(), config.mqtt.clone())
|
||||
let provider = BulbsMqtt::new(config.bulbs.clone(), config.mqtt.clone());
|
||||
let manager = BulbManager::launch(config.bulbs.clone(), provider)
|
||||
.await
|
||||
.expect("Failed to launch bulb manager");
|
||||
|
||||
let mut wake_tasks: HashMap<(BulbId, Weekday), JoinHandle<()>> = lights_state
|
||||
.get()
|
||||
.wake_schedule
|
||||
.iter()
|
||||
.flat_map(|(bulb, schedule)| schedule.iter().map(move |(day, time)| (bulb, day, time)))
|
||||
.map(|(bulb, day, time)| {
|
||||
let handle = spawn(wake_task(
|
||||
state.client_message.clone(),
|
||||
cmd.clone(),
|
||||
bulb.clone(),
|
||||
*day,
|
||||
*time,
|
||||
));
|
||||
let mut scripts: HashMap<ScriptId, Box<dyn LightScript + Send>> = Default::default();
|
||||
scripts.insert(
|
||||
"waker".to_string(),
|
||||
Box::new(Waker::create(manager.clone())),
|
||||
);
|
||||
scripts.insert(
|
||||
"party".to_string(),
|
||||
Box::new(Party::create(manager.clone())),
|
||||
);
|
||||
|
||||
((bulb.clone(), *day), handle)
|
||||
})
|
||||
.collect();
|
||||
for (script, prefs) in &lights_state.get().script_prefs {
|
||||
let Some(script) = scripts.get_mut(script) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
for (bulb, prefs) in prefs {
|
||||
for (name, value) in &prefs.kvs {
|
||||
script.set_param(bulb, name, value.clone())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
loop {
|
||||
let notify = bulb_states.notify_on_change();
|
||||
select! {
|
||||
_ = notify => {
|
||||
let lights_state = lights_state.get();
|
||||
for (id, mode) in bulb_states.bulbs().await.clone().into_iter() {
|
||||
let wake_schedule = lights_state.wake_schedule.get(&id).cloned().unwrap_or_default();
|
||||
let msg = ServerMessage::BulbState { id, mode, wake_schedule };
|
||||
_ = manager.notify_on_change() => {
|
||||
for (id, mode) in manager.bulbs().await.clone().into_iter() {
|
||||
let prefs = scripts.iter_mut()
|
||||
.map(|(script, prefs)|
|
||||
(script.clone(), prefs.get_params(&id)))
|
||||
.collect();
|
||||
|
||||
let msg = ServerMessage::BulbState { id, mode, prefs };
|
||||
if let Err(e) = server_message.send(msg) {
|
||||
error!("broadcast channel error: {e}");
|
||||
return;
|
||||
@ -73,58 +80,42 @@ pub async fn lights_task(state: &State) {
|
||||
|
||||
match request.message {
|
||||
ClientMessage::SetBulbColor { id, color } => {
|
||||
if let Err(e) = cmd.send(BulbCommand::SetColor(BulbSelector::Id(id), color)).await {
|
||||
error!("bulb manager error: {e}");
|
||||
}
|
||||
manager.send_command(BulbCommand::SetColor(BulbSelector::Id(id), color)).await;
|
||||
}
|
||||
ClientMessage::SetBulbPower { id, power } => {
|
||||
if let Err(e) = cmd.send(BulbCommand::SetPower(BulbSelector::Id(id), power)).await {
|
||||
error!("bulb manager error: {e}");
|
||||
}
|
||||
manager.send_command(BulbCommand::SetPower(BulbSelector::Id(id), power)).await;
|
||||
}
|
||||
ClientMessage::GetBulbs => {
|
||||
if let Err(e) = request.response.send(ServerMessage::BulbMap(config.bulb_map.clone())).await {
|
||||
error!("GetBulbs response channel error: {e}");
|
||||
return;
|
||||
}
|
||||
let lights_state = lights_state.get();
|
||||
for (id, mode) in bulb_states.bulbs().await.clone().into_iter() {
|
||||
let wake_schedule = lights_state.wake_schedule.get(&id).cloned().unwrap_or_default();
|
||||
let msg = ServerMessage::BulbState { id, mode, wake_schedule };
|
||||
for (id, mode) in manager.bulbs().await.clone().into_iter() {
|
||||
let prefs = scripts.iter_mut()
|
||||
.map(|(script, prefs)|
|
||||
(script.clone(), prefs.get_params(&id)))
|
||||
.collect();
|
||||
|
||||
let msg = ServerMessage::BulbState { id, mode, prefs };
|
||||
if let Err(e) = request.response.send(msg).await {
|
||||
error!("GetBulbs response channel error: {e}");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
ClientMessage::SetBulbWakeTime { id, day, time } => {
|
||||
if let Err(e) = lights_state.update(|lights_state| {
|
||||
let schedule = lights_state.wake_schedule.entry(id.clone()).or_default();
|
||||
if let Some(time) = time {
|
||||
schedule.insert(day, time);
|
||||
}
|
||||
else {
|
||||
schedule.remove(&day);
|
||||
}
|
||||
}).await {
|
||||
error!("Failed to save wake schedule: {e}");
|
||||
ClientMessage::SetBulbPref { bulb, script, name, value } => {
|
||||
let Some(s) = scripts.get_mut(&script) else {
|
||||
continue;
|
||||
};
|
||||
s.set_param(&bulb, &name, value.clone());
|
||||
|
||||
if let Some(time) = time {
|
||||
let handle = spawn(wake_task(
|
||||
state.client_message.clone(),
|
||||
cmd.clone(),
|
||||
id.clone(),
|
||||
day,
|
||||
time,
|
||||
));
|
||||
|
||||
if let Some(old_handle) = wake_tasks.insert((id, day), handle) {
|
||||
old_handle.abort();
|
||||
}
|
||||
} else if let Some(old_handle) = wake_tasks.remove(&(id, day)) {
|
||||
old_handle.abort();
|
||||
}
|
||||
// TODO handle error
|
||||
lights_state.update(move |state| {
|
||||
state.script_prefs
|
||||
.entry(script).or_default()
|
||||
.entry(bulb).or_default()
|
||||
.kvs.insert(name, value);
|
||||
}).await.expect("failed to persist lights state");
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
@ -132,112 +123,3 @@ pub async fn lights_task(state: &State) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn wake_task(
|
||||
client_messages: broadcast::Sender<ClientRequest>,
|
||||
cmd: mpsc::Sender<BulbCommand>,
|
||||
id: BulbId,
|
||||
day: Weekday,
|
||||
time: NaiveTime,
|
||||
) {
|
||||
let mut alarm = next_alarm(Local::now(), day, time);
|
||||
|
||||
loop {
|
||||
info!("sleeping until {alarm}");
|
||||
sleep((alarm - Local::now()).to_std().unwrap()).await;
|
||||
|
||||
// slowly turn up brightness of bulb
|
||||
for brightness in (1..=75).map(|i| (i as f32) * 0.01) {
|
||||
select! {
|
||||
// abort if the client pokes the bulb
|
||||
_ = wait_for_bulb_command(&id, client_messages.subscribe()) => break,
|
||||
_ = sleep(Duration::from_secs(12)) => {}
|
||||
};
|
||||
|
||||
if cmd
|
||||
.send(BulbCommand::SetColor(
|
||||
BulbSelector::Id(id.clone()),
|
||||
BulbColor::Kelvin {
|
||||
t: 0.0,
|
||||
b: brightness,
|
||||
},
|
||||
))
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
return;
|
||||
};
|
||||
}
|
||||
|
||||
alarm = next_alarm(Local::now(), day, time);
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the next alarm, from a weekday+time schedule.
|
||||
fn next_alarm(now: DateTime<Local>, day: Weekday, time: NaiveTime) -> DateTime<Local> {
|
||||
let day_of_alarm = day.num_days_from_monday() as i64;
|
||||
let day_now = now.weekday().num_days_from_monday() as i64;
|
||||
|
||||
let alarm = now + chrono::Duration::days(day_of_alarm - day_now);
|
||||
let mut alarm = alarm
|
||||
.date_naive()
|
||||
.and_time(time)
|
||||
.and_local_timezone(Local)
|
||||
.unwrap();
|
||||
|
||||
if alarm <= now {
|
||||
alarm += chrono::Duration::weeks(1);
|
||||
}
|
||||
|
||||
alarm
|
||||
}
|
||||
|
||||
/// Wait until we receive a client request that mutates the given bulb
|
||||
async fn wait_for_bulb_command(
|
||||
bulb_id: &BulbId,
|
||||
mut client_messages: broadcast::Receiver<ClientRequest>,
|
||||
) {
|
||||
loop {
|
||||
match client_messages.recv().await {
|
||||
Err(_) => return,
|
||||
Ok(request) => match request.message {
|
||||
ClientMessage::SetBulbColor { id, .. }
|
||||
| ClientMessage::SetBulbPower { id, .. }
|
||||
| ClientMessage::SetBulbWakeTime { id, .. }
|
||||
if &id == bulb_id =>
|
||||
{
|
||||
break
|
||||
}
|
||||
_ => continue,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use chrono::{offset::TimeZone, Local, NaiveTime, Weekday};
|
||||
|
||||
use super::next_alarm;
|
||||
|
||||
#[test]
|
||||
fn test_alarm_date() {
|
||||
const FMT: &str = "%Y-%m-%d %H:%M";
|
||||
let now = Local.datetime_from_str("2022-10-18 15:30", FMT).unwrap();
|
||||
let test_values = [
|
||||
(Weekday::Tue, (16, 30), "2022-10-18 16:30"),
|
||||
(Weekday::Tue, (14, 30), "2022-10-25 14:30"),
|
||||
(Weekday::Wed, (15, 30), "2022-10-19 15:30"),
|
||||
(Weekday::Mon, (15, 30), "2022-10-24 15:30"),
|
||||
];
|
||||
|
||||
for (day, (hour, min), expected) in test_values {
|
||||
let expected = Local.datetime_from_str(expected, FMT).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
next_alarm(now, day, NaiveTime::from_hms(hour, min, 0)),
|
||||
expected
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user